Trait sniffle::uint::BitPack

pub trait BitPack {
    type Packed;

    fn pack(self) -> Self::Packed;
    fn unpack(packed: Self::Packed) -> Self;
}

A trait that defines how to pack and unpack uints.

Implementing BitPack allows types to be used with the pack and unpack macros.

Required Associated Types

type Packed

Required Methods

fn pack(self) -> Self::Packed

fn unpack(packed: Self::Packed) -> Self

Implementations on Foreign Types

impl BitPack for (U2, U27)

type Packed = U29

fn pack(self) -> <(U2, U27) as BitPack>::Packed

fn unpack(packed: <(U2, U27) as BitPack>::Packed) -> (U2, U27)

impl BitPack for (U13, U39)

type Packed = U52

fn pack(self) -> <(U13, U39) as BitPack>::Packed

fn unpack(packed: <(U13, U39) as BitPack>::Packed) -> (U13, U39)

impl BitPack for (U2, u8)

type Packed = U10

fn pack(self) -> <(U2, u8) as BitPack>::Packed

fn unpack(packed: <(U2, u8) as BitPack>::Packed) -> (U2, u8)

impl BitPack for (U55, U6)

type Packed = U61

fn pack(self) -> <(U55, U6) as BitPack>::Packed

fn unpack(packed: <(U55, U6) as BitPack>::Packed) -> (U55, U6)

impl BitPack for (U2, U18)

type Packed = U20

fn pack(self) -> <(U2, U18) as BitPack>::Packed

fn unpack(packed: <(U2, U18) as BitPack>::Packed) -> (U2, U18)

impl BitPack for (U7, U44)

type Packed = U51

fn pack(self) -> <(U7, U44) as BitPack>::Packed

fn unpack(packed: <(U7, U44) as BitPack>::Packed) -> (U7, U44)

impl BitPack for (U31, U19)

type Packed = U50

fn pack(self) -> <(U31, U19) as BitPack>::Packed

fn unpack(packed: <(U31, U19) as BitPack>::Packed) -> (U31, U19)

impl BitPack for (U59, U1)

type Packed = U60

fn pack(self) -> <(U59, U1) as BitPack>::Packed

fn unpack(packed: <(U59, U1) as BitPack>::Packed) -> (U59, U1)

impl BitPack for (U30, U25)

type Packed = U55

fn pack(self) -> <(U30, U25) as BitPack>::Packed

fn unpack(packed: <(U30, U25) as BitPack>::Packed) -> (U30, U25)

impl BitPack for (U1, U58)

type Packed = U59

fn pack(self) -> <(U1, U58) as BitPack>::Packed

fn unpack(packed: <(U1, U58) as BitPack>::Packed) -> (U1, U58)

impl BitPack for (U51, U9)

type Packed = U60

fn pack(self) -> <(U51, U9) as BitPack>::Packed

fn unpack(packed: <(U51, U9) as BitPack>::Packed) -> (U51, U9)

impl BitPack for (U21, U27)

type Packed = U48

fn pack(self) -> <(U21, U27) as BitPack>::Packed

fn unpack(packed: <(U21, U27) as BitPack>::Packed) -> (U21, U27)

impl BitPack for (U13, U48)

type Packed = U61

fn pack(self) -> <(U13, U48) as BitPack>::Packed

fn unpack(packed: <(U13, U48) as BitPack>::Packed) -> (U13, U48)

impl BitPack for (U18, U43)

type Packed = U61

fn pack(self) -> <(U18, U43) as BitPack>::Packed

fn unpack(packed: <(U18, U43) as BitPack>::Packed) -> (U18, U43)

impl BitPack for (u16, U12)

type Packed = U28

fn pack(self) -> <(u16, U12) as BitPack>::Packed

fn unpack(packed: <(u16, U12) as BitPack>::Packed) -> (u16, U12)

impl BitPack for (U26, U5)

type Packed = U31

fn pack(self) -> <(U26, U5) as BitPack>::Packed

fn unpack(packed: <(U26, U5) as BitPack>::Packed) -> (U26, U5)

impl BitPack for (U59, U2)

type Packed = U61

fn pack(self) -> <(U59, U2) as BitPack>::Packed

fn unpack(packed: <(U59, U2) as BitPack>::Packed) -> (U59, U2)

impl BitPack for (u16, U17)

type Packed = U33

fn pack(self) -> <(u16, U17) as BitPack>::Packed

fn unpack(packed: <(u16, U17) as BitPack>::Packed) -> (u16, U17)

impl BitPack for (U33, U30)

type Packed = U63

fn pack(self) -> <(U33, U30) as BitPack>::Packed

fn unpack(packed: <(U33, U30) as BitPack>::Packed) -> (U33, U30)

impl BitPack for (U34, U30)

type Packed = u64

fn pack(self) -> <(U34, U30) as BitPack>::Packed

fn unpack(packed: <(U34, U30) as BitPack>::Packed) -> (U34, U30)

impl BitPack for (u8, U50)

type Packed = U58

fn pack(self) -> <(u8, U50) as BitPack>::Packed

fn unpack(packed: <(u8, U50) as BitPack>::Packed) -> (u8, U50)

impl BitPack for (U23, U5)

type Packed = U28

fn pack(self) -> <(U23, U5) as BitPack>::Packed

fn unpack(packed: <(U23, U5) as BitPack>::Packed) -> (U23, U5)

impl BitPack for (U29, U6)

type Packed = U35

fn pack(self) -> <(U29, U6) as BitPack>::Packed

fn unpack(packed: <(U29, U6) as BitPack>::Packed) -> (U29, U6)

impl BitPack for (U22, U18)

type Packed = U40

fn pack(self) -> <(U22, U18) as BitPack>::Packed

fn unpack(packed: <(U22, U18) as BitPack>::Packed) -> (U22, U18)

impl BitPack for (U50, U6)

type Packed = U56

fn pack(self) -> <(U50, U6) as BitPack>::Packed

fn unpack(packed: <(U50, U6) as BitPack>::Packed) -> (U50, U6)

impl BitPack for (U2, U22)

type Packed = U24

fn pack(self) -> <(U2, U22) as BitPack>::Packed

fn unpack(packed: <(U2, U22) as BitPack>::Packed) -> (U2, U22)

impl BitPack for (U33, U20)

type Packed = U53

fn pack(self) -> <(U33, U20) as BitPack>::Packed

fn unpack(packed: <(U33, U20) as BitPack>::Packed) -> (U33, U20)

impl BitPack for (U31, U21)

type Packed = U52

fn pack(self) -> <(U31, U21) as BitPack>::Packed

fn unpack(packed: <(U31, U21) as BitPack>::Packed) -> (U31, U21)

impl BitPack for (U46, U5)

type Packed = U51

fn pack(self) -> <(U46, U5) as BitPack>::Packed

fn unpack(packed: <(U46, U5) as BitPack>::Packed) -> (U46, U5)

impl BitPack for (U42, U13)

type Packed = U55

fn pack(self) -> <(U42, U13) as BitPack>::Packed

fn unpack(packed: <(U42, U13) as BitPack>::Packed) -> (U42, U13)

impl<T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T21, <(T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T21, <(T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U50, U5)

type Packed = U55

fn pack(self) -> <(U50, U5) as BitPack>::Packed

fn unpack(packed: <(U50, U5) as BitPack>::Packed) -> (U50, U5)

impl BitPack for (U10, U52)

type Packed = U62

fn pack(self) -> <(U10, U52) as BitPack>::Packed

fn unpack(packed: <(U10, U52) as BitPack>::Packed) -> (U10, U52)

impl BitPack for (U34, U21)

type Packed = U55

fn pack(self) -> <(U34, U21) as BitPack>::Packed

fn unpack(packed: <(U34, U21) as BitPack>::Packed) -> (U34, U21)

impl BitPack for (U13, U35)

type Packed = U48

fn pack(self) -> <(U13, U35) as BitPack>::Packed

fn unpack(packed: <(U13, U35) as BitPack>::Packed) -> (U13, U35)

impl BitPack for (U55, U1)

type Packed = U56

fn pack(self) -> <(U55, U1) as BitPack>::Packed

fn unpack(packed: <(U55, U1) as BitPack>::Packed) -> (U55, U1)

impl BitPack for (U13, U5)

type Packed = U18

fn pack(self) -> <(U13, U5) as BitPack>::Packed

fn unpack(packed: <(U13, U5) as BitPack>::Packed) -> (U13, U5)

impl BitPack for (U28, U5)

type Packed = U33

fn pack(self) -> <(U28, U5) as BitPack>::Packed

fn unpack(packed: <(U28, U5) as BitPack>::Packed) -> (U28, U5)

impl<T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T15, <(T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T15, <(T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U30, U14)

type Packed = U44

fn pack(self) -> <(U30, U14) as BitPack>::Packed

fn unpack(packed: <(U30, U14) as BitPack>::Packed) -> (U30, U14)

impl<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T2, <(T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T2, <(T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U7, U19)

type Packed = U26

fn pack(self) -> <(U7, U19) as BitPack>::Packed

fn unpack(packed: <(U7, U19) as BitPack>::Packed) -> (U7, U19)

impl BitPack for (U7, U21)

type Packed = U28

fn pack(self) -> <(U7, U21) as BitPack>::Packed

fn unpack(packed: <(U7, U21) as BitPack>::Packed) -> (U7, U21)

impl BitPack for (U31, U25)

type Packed = U56

fn pack(self) -> <(U31, U25) as BitPack>::Packed

fn unpack(packed: <(U31, U25) as BitPack>::Packed) -> (U31, U25)

impl BitPack for (U11, U33)

type Packed = U44

fn pack(self) -> <(U11, U33) as BitPack>::Packed

fn unpack(packed: <(U11, U33) as BitPack>::Packed) -> (U11, U33)

impl BitPack for (U17, U18)

type Packed = U35

fn pack(self) -> <(U17, U18) as BitPack>::Packed

fn unpack(packed: <(U17, U18) as BitPack>::Packed) -> (U17, U18)

impl BitPack for (U22, u8)

type Packed = U30

fn pack(self) -> <(U22, u8) as BitPack>::Packed

fn unpack(packed: <(U22, u8) as BitPack>::Packed) -> (U22, u8)

impl BitPack for (U1, U25)

type Packed = U26

fn pack(self) -> <(U1, U25) as BitPack>::Packed

fn unpack(packed: <(U1, U25) as BitPack>::Packed) -> (U1, U25)

impl BitPack for (U4, U7)

type Packed = U11

fn pack(self) -> <(U4, U7) as BitPack>::Packed

fn unpack(packed: <(U4, U7) as BitPack>::Packed) -> (U4, U7)

impl BitPack for (U11, U35)

type Packed = U46

fn pack(self) -> <(U11, U35) as BitPack>::Packed

fn unpack(packed: <(U11, U35) as BitPack>::Packed) -> (U11, U35)

impl BitPack for (U6, U28)

type Packed = U34

fn pack(self) -> <(U6, U28) as BitPack>::Packed

fn unpack(packed: <(U6, U28) as BitPack>::Packed) -> (U6, U28)

impl BitPack for (U54, U7)

type Packed = U61

fn pack(self) -> <(U54, U7) as BitPack>::Packed

fn unpack(packed: <(U54, U7) as BitPack>::Packed) -> (U54, U7)

impl BitPack for (U1, U19)

type Packed = U20

fn pack(self) -> <(U1, U19) as BitPack>::Packed

fn unpack(packed: <(U1, U19) as BitPack>::Packed) -> (U1, U19)

impl BitPack for (U11, U25)

type Packed = U36

fn pack(self) -> <(U11, U25) as BitPack>::Packed

fn unpack(packed: <(U11, U25) as BitPack>::Packed) -> (U11, U25)

impl BitPack for (U23, U35)

type Packed = U58

fn pack(self) -> <(U23, U35) as BitPack>::Packed

fn unpack(packed: <(U23, U35) as BitPack>::Packed) -> (U23, U35)

impl BitPack for (U49, U13)

type Packed = U62

fn pack(self) -> <(U49, U13) as BitPack>::Packed

fn unpack(packed: <(U49, U13) as BitPack>::Packed) -> (U49, U13)

impl BitPack for (U3, U60)

type Packed = U63

fn pack(self) -> <(U3, U60) as BitPack>::Packed

fn unpack(packed: <(U3, U60) as BitPack>::Packed) -> (U3, U60)

impl BitPack for (U38, U7)

type Packed = U45

fn pack(self) -> <(U38, U7) as BitPack>::Packed

fn unpack(packed: <(U38, U7) as BitPack>::Packed) -> (U38, U7)

impl BitPack for (U2, U45)

type Packed = U47

fn pack(self) -> <(U2, U45) as BitPack>::Packed

fn unpack(packed: <(U2, U45) as BitPack>::Packed) -> (U2, U45)

impl BitPack for (U23, U29)

type Packed = U52

fn pack(self) -> <(U23, U29) as BitPack>::Packed

fn unpack(packed: <(U23, U29) as BitPack>::Packed) -> (U23, U29)

impl BitPack for (U12, U4)

type Packed = u16

fn pack(self) -> <(U12, U4) as BitPack>::Packed

fn unpack(packed: <(U12, U4) as BitPack>::Packed) -> (U12, U4)

impl BitPack for (U18, U21)

type Packed = U39

fn pack(self) -> <(U18, U21) as BitPack>::Packed

fn unpack(packed: <(U18, U21) as BitPack>::Packed) -> (U18, U21)

impl BitPack for (U12, u16)

type Packed = U28

fn pack(self) -> <(U12, u16) as BitPack>::Packed

fn unpack(packed: <(U12, u16) as BitPack>::Packed) -> (U12, u16)

impl BitPack for (U15, U37)

type Packed = U52

fn pack(self) -> <(U15, U37) as BitPack>::Packed

fn unpack(packed: <(U15, U37) as BitPack>::Packed) -> (U15, U37)

impl BitPack for (U1, U54)

type Packed = U55

fn pack(self) -> <(U1, U54) as BitPack>::Packed

fn unpack(packed: <(U1, U54) as BitPack>::Packed) -> (U1, U54)

impl BitPack for (U54, U10)

type Packed = u64

fn pack(self) -> <(U54, U10) as BitPack>::Packed

fn unpack(packed: <(U54, U10) as BitPack>::Packed) -> (U54, U10)

impl<T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T52, <(T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T52, <(T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U33, U12)

type Packed = U45

fn pack(self) -> <(U33, U12) as BitPack>::Packed

fn unpack(packed: <(U33, U12) as BitPack>::Packed) -> (U33, U12)

impl BitPack for (U3, U19)

type Packed = U22

fn pack(self) -> <(U3, U19) as BitPack>::Packed

fn unpack(packed: <(U3, U19) as BitPack>::Packed) -> (U3, U19)

impl BitPack for (U15, U24)

type Packed = U39

fn pack(self) -> <(U15, U24) as BitPack>::Packed

fn unpack(packed: <(U15, U24) as BitPack>::Packed) -> (U15, U24)

impl BitPack for (U21, U33)

type Packed = U54

fn pack(self) -> <(U21, U33) as BitPack>::Packed

fn unpack(packed: <(U21, U33) as BitPack>::Packed) -> (U21, U33)

impl BitPack for (U33, U23)

type Packed = U56

fn pack(self) -> <(U33, U23) as BitPack>::Packed

fn unpack(packed: <(U33, U23) as BitPack>::Packed) -> (U33, U23)

impl BitPack for (U4, U40)

type Packed = U44

fn pack(self) -> <(U4, U40) as BitPack>::Packed

fn unpack(packed: <(U4, U40) as BitPack>::Packed) -> (U4, U40)

impl BitPack for (U23, U12)

type Packed = U35

fn pack(self) -> <(U23, U12) as BitPack>::Packed

fn unpack(packed: <(U23, U12) as BitPack>::Packed) -> (U23, U12)

impl BitPack for (U9, U5)

type Packed = U14

fn pack(self) -> <(U9, U5) as BitPack>::Packed

fn unpack(packed: <(U9, U5) as BitPack>::Packed) -> (U9, U5)

impl BitPack for (U46, U18)

type Packed = u64

fn pack(self) -> <(U46, U18) as BitPack>::Packed

fn unpack(packed: <(U46, U18) as BitPack>::Packed) -> (U46, U18)

impl BitPack for (U4, U49)

type Packed = U53

fn pack(self) -> <(U4, U49) as BitPack>::Packed

fn unpack(packed: <(U4, U49) as BitPack>::Packed) -> (U4, U49)

impl BitPack for (U18, U31)

type Packed = U49

fn pack(self) -> <(U18, U31) as BitPack>::Packed

fn unpack(packed: <(U18, U31) as BitPack>::Packed) -> (U18, U31)

impl BitPack for (U4, U24)

type Packed = U28

fn pack(self) -> <(U4, U24) as BitPack>::Packed

fn unpack(packed: <(U4, U24) as BitPack>::Packed) -> (U4, U24)

impl BitPack for (U9, U28)

type Packed = U37

fn pack(self) -> <(U9, U28) as BitPack>::Packed

fn unpack(packed: <(U9, U28) as BitPack>::Packed) -> (U9, U28)

impl BitPack for (U22, U9)

type Packed = U31

fn pack(self) -> <(U22, U9) as BitPack>::Packed

fn unpack(packed: <(U22, U9) as BitPack>::Packed) -> (U22, U9)

impl BitPack for (U37, u16)

type Packed = U53

fn pack(self) -> <(U37, u16) as BitPack>::Packed

fn unpack(packed: <(U37, u16) as BitPack>::Packed) -> (U37, u16)

impl BitPack for (U31, U13)

type Packed = U44

fn pack(self) -> <(U31, U13) as BitPack>::Packed

fn unpack(packed: <(U31, U13) as BitPack>::Packed) -> (U31, U13)

impl BitPack for (U26, U24)

type Packed = U50

fn pack(self) -> <(U26, U24) as BitPack>::Packed

fn unpack(packed: <(U26, U24) as BitPack>::Packed) -> (U26, U24)

impl BitPack for (U28, U14)

type Packed = U42

fn pack(self) -> <(U28, U14) as BitPack>::Packed

fn unpack(packed: <(U28, U14) as BitPack>::Packed) -> (U28, U14)

impl BitPack for (U5, U49)

type Packed = U54

fn pack(self) -> <(U5, U49) as BitPack>::Packed

fn unpack(packed: <(U5, U49) as BitPack>::Packed) -> (U5, U49)

impl BitPack for (U7, U38)

type Packed = U45

fn pack(self) -> <(U7, U38) as BitPack>::Packed

fn unpack(packed: <(U7, U38) as BitPack>::Packed) -> (U7, U38)

impl BitPack for (U27, U28)

type Packed = U55

fn pack(self) -> <(U27, U28) as BitPack>::Packed

fn unpack(packed: <(U27, U28) as BitPack>::Packed) -> (U27, U28)

impl BitPack for (U36, U23)

type Packed = U59

fn pack(self) -> <(U36, U23) as BitPack>::Packed

fn unpack(packed: <(U36, U23) as BitPack>::Packed) -> (U36, U23)

impl BitPack for (U30, U7)

type Packed = U37

fn pack(self) -> <(U30, U7) as BitPack>::Packed

fn unpack(packed: <(U30, U7) as BitPack>::Packed) -> (U30, U7)

impl BitPack for (U39, U4)

type Packed = U43

fn pack(self) -> <(U39, U4) as BitPack>::Packed

fn unpack(packed: <(U39, U4) as BitPack>::Packed) -> (U39, U4)

impl BitPack for (U14, U35)

type Packed = U49

fn pack(self) -> <(U14, U35) as BitPack>::Packed

fn unpack(packed: <(U14, U35) as BitPack>::Packed) -> (U14, U35)

impl BitPack for (u32, U10)

type Packed = U42

fn pack(self) -> <(u32, U10) as BitPack>::Packed

fn unpack(packed: <(u32, U10) as BitPack>::Packed) -> (u32, U10)

impl BitPack for (U17, U10)

type Packed = U27

fn pack(self) -> <(U17, U10) as BitPack>::Packed

fn unpack(packed: <(U17, U10) as BitPack>::Packed) -> (U17, U10)

impl BitPack for (U2, U59)

type Packed = U61

fn pack(self) -> <(U2, U59) as BitPack>::Packed

fn unpack(packed: <(U2, U59) as BitPack>::Packed) -> (U2, U59)

impl BitPack for (U49, U10)

type Packed = U59

fn pack(self) -> <(U49, U10) as BitPack>::Packed

fn unpack(packed: <(U49, U10) as BitPack>::Packed) -> (U49, U10)

impl BitPack for (U25, U22)

type Packed = U47

fn pack(self) -> <(U25, U22) as BitPack>::Packed

fn unpack(packed: <(U25, U22) as BitPack>::Packed) -> (U25, U22)

impl BitPack for (U12, U14)

type Packed = U26

fn pack(self) -> <(U12, U14) as BitPack>::Packed

fn unpack(packed: <(U12, U14) as BitPack>::Packed) -> (U12, U14)

impl BitPack for (U33, U7)

type Packed = U40

fn pack(self) -> <(U33, U7) as BitPack>::Packed

fn unpack(packed: <(U33, U7) as BitPack>::Packed) -> (U33, U7)

impl BitPack for (U2, U29)

type Packed = U31

fn pack(self) -> <(U2, U29) as BitPack>::Packed

fn unpack(packed: <(U2, U29) as BitPack>::Packed) -> (U2, U29)

impl BitPack for (u16, U1)

type Packed = U17

fn pack(self) -> <(u16, U1) as BitPack>::Packed

fn unpack(packed: <(u16, U1) as BitPack>::Packed) -> (u16, U1)

impl BitPack for (U39, U2)

type Packed = U41

fn pack(self) -> <(U39, U2) as BitPack>::Packed

fn unpack(packed: <(U39, U2) as BitPack>::Packed) -> (U39, U2)

impl BitPack for (U10, U31)

type Packed = U41

fn pack(self) -> <(U10, U31) as BitPack>::Packed

fn unpack(packed: <(U10, U31) as BitPack>::Packed) -> (U10, U31)

impl BitPack for (U35, U15)

type Packed = U50

fn pack(self) -> <(U35, U15) as BitPack>::Packed

fn unpack(packed: <(U35, U15) as BitPack>::Packed) -> (U35, U15)

impl BitPack for (U19, U4)

type Packed = U23

fn pack(self) -> <(U19, U4) as BitPack>::Packed

fn unpack(packed: <(U19, U4) as BitPack>::Packed) -> (U19, U4)

impl BitPack for (U37, U3)

type Packed = U40

fn pack(self) -> <(U37, U3) as BitPack>::Packed

fn unpack(packed: <(U37, U3) as BitPack>::Packed) -> (U37, U3)

impl BitPack for (u16, U7)

type Packed = U23

fn pack(self) -> <(u16, U7) as BitPack>::Packed

fn unpack(packed: <(u16, U7) as BitPack>::Packed) -> (u16, U7)

impl BitPack for (u8, U24)

type Packed = u32

fn pack(self) -> <(u8, U24) as BitPack>::Packed

fn unpack(packed: <(u8, U24) as BitPack>::Packed) -> (u8, U24)

impl BitPack for (U17, U15)

type Packed = u32

fn pack(self) -> <(U17, U15) as BitPack>::Packed

fn unpack(packed: <(U17, U15) as BitPack>::Packed) -> (U17, U15)

impl BitPack for (U42, U14)

type Packed = U56

fn pack(self) -> <(U42, U14) as BitPack>::Packed

fn unpack(packed: <(U42, U14) as BitPack>::Packed) -> (U42, U14)

impl BitPack for (U19, U1)

type Packed = U20

fn pack(self) -> <(U19, U1) as BitPack>::Packed

fn unpack(packed: <(U19, U1) as BitPack>::Packed) -> (U19, U1)

impl BitPack for (U59, U5)

type Packed = u64

fn pack(self) -> <(U59, U5) as BitPack>::Packed

fn unpack(packed: <(U59, U5) as BitPack>::Packed) -> (U59, U5)

impl BitPack for (U1, U43)

type Packed = U44

fn pack(self) -> <(U1, U43) as BitPack>::Packed

fn unpack(packed: <(U1, U43) as BitPack>::Packed) -> (U1, U43)

impl BitPack for (U52, U11)

type Packed = U63

fn pack(self) -> <(U52, U11) as BitPack>::Packed

fn unpack(packed: <(U52, U11) as BitPack>::Packed) -> (U52, U11)

impl BitPack for (U1, U56)

type Packed = U57

fn pack(self) -> <(U1, U56) as BitPack>::Packed

fn unpack(packed: <(U1, U56) as BitPack>::Packed) -> (U1, U56)

impl BitPack for (U50, U9)

type Packed = U59

fn pack(self) -> <(U50, U9) as BitPack>::Packed

fn unpack(packed: <(U50, U9) as BitPack>::Packed) -> (U50, U9)

impl BitPack for (U24, U10)

type Packed = U34

fn pack(self) -> <(U24, U10) as BitPack>::Packed

fn unpack(packed: <(U24, U10) as BitPack>::Packed) -> (U24, U10)

impl BitPack for (U47, U4)

type Packed = U51

fn pack(self) -> <(U47, U4) as BitPack>::Packed

fn unpack(packed: <(U47, U4) as BitPack>::Packed) -> (U47, U4)

impl BitPack for (U14, U3)

type Packed = U17

fn pack(self) -> <(U14, U3) as BitPack>::Packed

fn unpack(packed: <(U14, U3) as BitPack>::Packed) -> (U14, U3)

impl BitPack for (U22, U34)

type Packed = U56

fn pack(self) -> <(U22, U34) as BitPack>::Packed

fn unpack(packed: <(U22, U34) as BitPack>::Packed) -> (U22, U34)

impl BitPack for (U9, U34)

type Packed = U43

fn pack(self) -> <(U9, U34) as BitPack>::Packed

fn unpack(packed: <(U9, U34) as BitPack>::Packed) -> (U9, U34)

impl BitPack for (U5, U18)

type Packed = U23

fn pack(self) -> <(U5, U18) as BitPack>::Packed

fn unpack(packed: <(U5, U18) as BitPack>::Packed) -> (U5, U18)

impl BitPack for (U13, U36)

type Packed = U49

fn pack(self) -> <(U13, U36) as BitPack>::Packed

fn unpack(packed: <(U13, U36) as BitPack>::Packed) -> (U13, U36)

impl BitPack for (U35, U21)

type Packed = U56

fn pack(self) -> <(U35, U21) as BitPack>::Packed

fn unpack(packed: <(U35, U21) as BitPack>::Packed) -> (U35, U21)

impl BitPack for (U40, U21)

type Packed = U61

fn pack(self) -> <(U40, U21) as BitPack>::Packed

fn unpack(packed: <(U40, U21) as BitPack>::Packed) -> (U40, U21)

impl BitPack for (U23, U33)

type Packed = U56

fn pack(self) -> <(U23, U33) as BitPack>::Packed

fn unpack(packed: <(U23, U33) as BitPack>::Packed) -> (U23, U33)

impl BitPack for (U11, U24)

type Packed = U35

fn pack(self) -> <(U11, U24) as BitPack>::Packed

fn unpack(packed: <(U11, U24) as BitPack>::Packed) -> (U11, U24)

impl BitPack for (u16, U31)

type Packed = U47

fn pack(self) -> <(u16, U31) as BitPack>::Packed

fn unpack(packed: <(u16, U31) as BitPack>::Packed) -> (u16, U31)

impl BitPack for (U17, U23)

type Packed = U40

fn pack(self) -> <(U17, U23) as BitPack>::Packed

fn unpack(packed: <(U17, U23) as BitPack>::Packed) -> (U17, U23)

impl BitPack for (U1, U2)

type Packed = U3

fn pack(self) -> <(U1, U2) as BitPack>::Packed

fn unpack(packed: <(U1, U2) as BitPack>::Packed) -> (U1, U2)

impl BitPack for (U42, U18)

type Packed = U60

fn pack(self) -> <(U42, U18) as BitPack>::Packed

fn unpack(packed: <(U42, U18) as BitPack>::Packed) -> (U42, U18)

impl BitPack for (U33, U27)

type Packed = U60

fn pack(self) -> <(U33, U27) as BitPack>::Packed

fn unpack(packed: <(U33, U27) as BitPack>::Packed) -> (U33, U27)

impl BitPack for (U9, U9)

type Packed = U18

fn pack(self) -> <(U9, U9) as BitPack>::Packed

fn unpack(packed: <(U9, U9) as BitPack>::Packed) -> (U9, U9)

impl BitPack for (U21, u32)

type Packed = U53

fn pack(self) -> <(U21, u32) as BitPack>::Packed

fn unpack(packed: <(U21, u32) as BitPack>::Packed) -> (U21, u32)

impl BitPack for (U12, U5)

type Packed = U17

fn pack(self) -> <(U12, U5) as BitPack>::Packed

fn unpack(packed: <(U12, U5) as BitPack>::Packed) -> (U12, U5)

impl BitPack for (U18, u16)

type Packed = U34

fn pack(self) -> <(U18, u16) as BitPack>::Packed

fn unpack(packed: <(U18, u16) as BitPack>::Packed) -> (U18, u16)

impl BitPack for (U23, U14)

type Packed = U37

fn pack(self) -> <(U23, U14) as BitPack>::Packed

fn unpack(packed: <(U23, U14) as BitPack>::Packed) -> (U23, U14)

impl BitPack for (U18, U33)

type Packed = U51

fn pack(self) -> <(U18, U33) as BitPack>::Packed

fn unpack(packed: <(U18, U33) as BitPack>::Packed) -> (U18, U33)

impl BitPack for (U46, U13)

type Packed = U59

fn pack(self) -> <(U46, U13) as BitPack>::Packed

fn unpack(packed: <(U46, U13) as BitPack>::Packed) -> (U46, U13)

impl BitPack for (U10, U23)

type Packed = U33

fn pack(self) -> <(U10, U23) as BitPack>::Packed

fn unpack(packed: <(U10, U23) as BitPack>::Packed) -> (U10, U23)

impl BitPack for (U2, U62)

type Packed = u64

fn pack(self) -> <(U2, U62) as BitPack>::Packed

fn unpack(packed: <(U2, U62) as BitPack>::Packed) -> (U2, U62)

impl BitPack for (U9, U42)

type Packed = U51

fn pack(self) -> <(U9, U42) as BitPack>::Packed

fn unpack(packed: <(U9, U42) as BitPack>::Packed) -> (U9, U42)

impl BitPack for (U7, U37)

type Packed = U44

fn pack(self) -> <(U7, U37) as BitPack>::Packed

fn unpack(packed: <(U7, U37) as BitPack>::Packed) -> (U7, U37)

impl BitPack for (U58, U3)

type Packed = U61

fn pack(self) -> <(U58, U3) as BitPack>::Packed

fn unpack(packed: <(U58, U3) as BitPack>::Packed) -> (U58, U3)

impl BitPack for (U15, U23)

type Packed = U38

fn pack(self) -> <(U15, U23) as BitPack>::Packed

fn unpack(packed: <(U15, U23) as BitPack>::Packed) -> (U15, U23)

impl BitPack for (U37, U25)

type Packed = U62

fn pack(self) -> <(U37, U25) as BitPack>::Packed

fn unpack(packed: <(U37, U25) as BitPack>::Packed) -> (U37, U25)

impl BitPack for (U44, U19)

type Packed = U63

fn pack(self) -> <(U44, U19) as BitPack>::Packed

fn unpack(packed: <(U44, U19) as BitPack>::Packed) -> (U44, U19)

impl BitPack for (U55, U9)

type Packed = u64

fn pack(self) -> <(U55, U9) as BitPack>::Packed

fn unpack(packed: <(U55, U9) as BitPack>::Packed) -> (U55, U9)

impl BitPack for (U11, U27)

type Packed = U38

fn pack(self) -> <(U11, U27) as BitPack>::Packed

fn unpack(packed: <(U11, U27) as BitPack>::Packed) -> (U11, U27)

impl<T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T8, <(T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T8, <(T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U57, U4)

type Packed = U61

fn pack(self) -> <(U57, U4) as BitPack>::Packed

fn unpack(packed: <(U57, U4) as BitPack>::Packed) -> (U57, U4)

impl BitPack for (U41, U15)

type Packed = U56

fn pack(self) -> <(U41, U15) as BitPack>::Packed

fn unpack(packed: <(U41, U15) as BitPack>::Packed) -> (U41, U15)

impl BitPack for (U26, U4)

type Packed = U30

fn pack(self) -> <(U26, U4) as BitPack>::Packed

fn unpack(packed: <(U26, U4) as BitPack>::Packed) -> (U26, U4)

impl BitPack for (U26, U12)

type Packed = U38

fn pack(self) -> <(U26, U12) as BitPack>::Packed

fn unpack(packed: <(U26, U12) as BitPack>::Packed) -> (U26, U12)

impl BitPack for (U44, U4)

type Packed = U48

fn pack(self) -> <(U44, U4) as BitPack>::Packed

fn unpack(packed: <(U44, U4) as BitPack>::Packed) -> (U44, U4)

impl BitPack for (U51, U1)

type Packed = U52

fn pack(self) -> <(U51, U1) as BitPack>::Packed

fn unpack(packed: <(U51, U1) as BitPack>::Packed) -> (U51, U1)

impl BitPack for (U2, U1)

type Packed = U3

fn pack(self) -> <(U2, U1) as BitPack>::Packed

fn unpack(packed: <(U2, U1) as BitPack>::Packed) -> (U2, U1)

impl BitPack for (U41, U22)

type Packed = U63

fn pack(self) -> <(U41, U22) as BitPack>::Packed

fn unpack(packed: <(U41, U22) as BitPack>::Packed) -> (U41, U22)

impl BitPack for (U61, U1)

type Packed = U62

fn pack(self) -> <(U61, U1) as BitPack>::Packed

fn unpack(packed: <(U61, U1) as BitPack>::Packed) -> (U61, U1)

impl BitPack for (U25, U27)

type Packed = U52

fn pack(self) -> <(U25, U27) as BitPack>::Packed

fn unpack(packed: <(U25, U27) as BitPack>::Packed) -> (U25, U27)

impl BitPack for (U19, U22)

type Packed = U41

fn pack(self) -> <(U19, U22) as BitPack>::Packed

fn unpack(packed: <(U19, U22) as BitPack>::Packed) -> (U19, U22)

impl BitPack for (U33, U1)

type Packed = U34

fn pack(self) -> <(U33, U1) as BitPack>::Packed

fn unpack(packed: <(U33, U1) as BitPack>::Packed) -> (U33, U1)

impl BitPack for (U34, U6)

type Packed = U40

fn pack(self) -> <(U34, U6) as BitPack>::Packed

fn unpack(packed: <(U34, U6) as BitPack>::Packed) -> (U34, U6)

impl BitPack for (u16, U22)

type Packed = U38

fn pack(self) -> <(u16, U22) as BitPack>::Packed

fn unpack(packed: <(u16, U22) as BitPack>::Packed) -> (u16, U22)

impl<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T3, <(T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T3, <(T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U29, U27)

type Packed = U56

fn pack(self) -> <(U29, U27) as BitPack>::Packed

fn unpack(packed: <(U29, U27) as BitPack>::Packed) -> (U29, U27)

impl BitPack for (U4, U56)

type Packed = U60

fn pack(self) -> <(U4, U56) as BitPack>::Packed

fn unpack(packed: <(U4, U56) as BitPack>::Packed) -> (U4, U56)

impl BitPack for (U10, U47)

type Packed = U57

fn pack(self) -> <(U10, U47) as BitPack>::Packed

fn unpack(packed: <(U10, U47) as BitPack>::Packed) -> (U10, U47)

impl BitPack for (U42, U10)

type Packed = U52

fn pack(self) -> <(U42, U10) as BitPack>::Packed

fn unpack(packed: <(U42, U10) as BitPack>::Packed) -> (U42, U10)

impl BitPack for (U38, U9)

type Packed = U47

fn pack(self) -> <(U38, U9) as BitPack>::Packed

fn unpack(packed: <(U38, U9) as BitPack>::Packed) -> (U38, U9)

impl BitPack for (U34, U17)

type Packed = U51

fn pack(self) -> <(U34, U17) as BitPack>::Packed

fn unpack(packed: <(U34, U17) as BitPack>::Packed) -> (U34, U17)

impl BitPack for (U25, U23)

type Packed = U48

fn pack(self) -> <(U25, U23) as BitPack>::Packed

fn unpack(packed: <(U25, U23) as BitPack>::Packed) -> (U25, U23)

impl BitPack for (U23, U36)

type Packed = U59

fn pack(self) -> <(U23, U36) as BitPack>::Packed

fn unpack(packed: <(U23, U36) as BitPack>::Packed) -> (U23, U36)

impl BitPack for (u16, U20)

type Packed = U36

fn pack(self) -> <(u16, U20) as BitPack>::Packed

fn unpack(packed: <(u16, U20) as BitPack>::Packed) -> (u16, U20)

impl BitPack for (U31, U14)

type Packed = U45

fn pack(self) -> <(U31, U14) as BitPack>::Packed

fn unpack(packed: <(U31, U14) as BitPack>::Packed) -> (U31, U14)

impl BitPack for (U22, U36)

type Packed = U58

fn pack(self) -> <(U22, U36) as BitPack>::Packed

fn unpack(packed: <(U22, U36) as BitPack>::Packed) -> (U22, U36)

impl BitPack for (u32, U14)

type Packed = U46

fn pack(self) -> <(u32, U14) as BitPack>::Packed

fn unpack(packed: <(u32, U14) as BitPack>::Packed) -> (u32, U14)

impl<T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T12, <(T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T12, <(T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (u8, U41)

type Packed = U49

fn pack(self) -> <(u8, U41) as BitPack>::Packed

fn unpack(packed: <(u8, U41) as BitPack>::Packed) -> (u8, U41)

impl<T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T10, <(T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T10, <(T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U14, U46)

type Packed = U60

fn pack(self) -> <(U14, U46) as BitPack>::Packed

fn unpack(packed: <(U14, U46) as BitPack>::Packed) -> (U14, U46)

impl BitPack for (U57, U3)

type Packed = U60

fn pack(self) -> <(U57, U3) as BitPack>::Packed

fn unpack(packed: <(U57, U3) as BitPack>::Packed) -> (U57, U3)

impl BitPack for (U41, U21)

type Packed = U62

fn pack(self) -> <(U41, U21) as BitPack>::Packed

fn unpack(packed: <(U41, U21) as BitPack>::Packed) -> (U41, U21)

impl BitPack for (U7, u32)

type Packed = U39

fn pack(self) -> <(U7, u32) as BitPack>::Packed

fn unpack(packed: <(U7, u32) as BitPack>::Packed) -> (U7, u32)

impl BitPack for (U23, U26)

type Packed = U49

fn pack(self) -> <(U23, U26) as BitPack>::Packed

fn unpack(packed: <(U23, U26) as BitPack>::Packed) -> (U23, U26)

impl<T61, T62, T63, T64> BitPack for (T61, T62, T63, T64)where
    (T62, T63, T64): BitPack,
    (T61, <(T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T61, <(T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(self) -> <(T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T61, T62, T63, T64) as BitPack>::Packed
) -> (T61, T62, T63, T64)

impl BitPack for (U33, u16)

type Packed = U49

fn pack(self) -> <(U33, u16) as BitPack>::Packed

fn unpack(packed: <(U33, u16) as BitPack>::Packed) -> (U33, u16)

impl BitPack for (U10, U11)

type Packed = U21

fn pack(self) -> <(U10, U11) as BitPack>::Packed

fn unpack(packed: <(U10, U11) as BitPack>::Packed) -> (U10, U11)

impl BitPack for (U27, U27)

type Packed = U54

fn pack(self) -> <(U27, U27) as BitPack>::Packed

fn unpack(packed: <(U27, U27) as BitPack>::Packed) -> (U27, U27)

impl BitPack for (U4, U18)

type Packed = U22

fn pack(self) -> <(U4, U18) as BitPack>::Packed

fn unpack(packed: <(U4, U18) as BitPack>::Packed) -> (U4, U18)

impl BitPack for (U18, U35)

type Packed = U53

fn pack(self) -> <(U18, U35) as BitPack>::Packed

fn unpack(packed: <(U18, U35) as BitPack>::Packed) -> (U18, U35)

impl BitPack for (U29, U12)

type Packed = U41

fn pack(self) -> <(U29, U12) as BitPack>::Packed

fn unpack(packed: <(U29, U12) as BitPack>::Packed) -> (U29, U12)

impl BitPack for (U22, U10)

type Packed = u32

fn pack(self) -> <(U22, U10) as BitPack>::Packed

fn unpack(packed: <(U22, U10) as BitPack>::Packed) -> (U22, U10)

impl BitPack for (U17, U29)

type Packed = U46

fn pack(self) -> <(U17, U29) as BitPack>::Packed

fn unpack(packed: <(U17, U29) as BitPack>::Packed) -> (U17, U29)

impl BitPack for (U44, U17)

type Packed = U61

fn pack(self) -> <(U44, U17) as BitPack>::Packed

fn unpack(packed: <(U44, U17) as BitPack>::Packed) -> (U44, U17)

impl BitPack for (U24, U28)

type Packed = U52

fn pack(self) -> <(U24, U28) as BitPack>::Packed

fn unpack(packed: <(U24, U28) as BitPack>::Packed) -> (U24, U28)

impl BitPack for (U10, U53)

type Packed = U63

fn pack(self) -> <(U10, U53) as BitPack>::Packed

fn unpack(packed: <(U10, U53) as BitPack>::Packed) -> (U10, U53)

impl BitPack for (U38, U5)

type Packed = U43

fn pack(self) -> <(U38, U5) as BitPack>::Packed

fn unpack(packed: <(U38, U5) as BitPack>::Packed) -> (U38, U5)

impl BitPack for (U9, U15)

type Packed = U24

fn pack(self) -> <(U9, U15) as BitPack>::Packed

fn unpack(packed: <(U9, U15) as BitPack>::Packed) -> (U9, U15)

impl BitPack for (U9, U49)

type Packed = U58

fn pack(self) -> <(U9, U49) as BitPack>::Packed

fn unpack(packed: <(U9, U49) as BitPack>::Packed) -> (U9, U49)

impl BitPack for (U9, U31)

type Packed = U40

fn pack(self) -> <(U9, U31) as BitPack>::Packed

fn unpack(packed: <(U9, U31) as BitPack>::Packed) -> (U9, U31)

impl BitPack for (U23, U13)

type Packed = U36

fn pack(self) -> <(U23, U13) as BitPack>::Packed

fn unpack(packed: <(U23, U13) as BitPack>::Packed) -> (U23, U13)

impl BitPack for (u8, U25)

type Packed = U33

fn pack(self) -> <(u8, U25) as BitPack>::Packed

fn unpack(packed: <(u8, U25) as BitPack>::Packed) -> (u8, U25)

impl BitPack for (U4, U10)

type Packed = U14

fn pack(self) -> <(U4, U10) as BitPack>::Packed

fn unpack(packed: <(U4, U10) as BitPack>::Packed) -> (U4, U10)

impl BitPack for (U4, U15)

type Packed = U19

fn pack(self) -> <(U4, U15) as BitPack>::Packed

fn unpack(packed: <(U4, U15) as BitPack>::Packed) -> (U4, U15)

impl BitPack for (U5, U38)

type Packed = U43

fn pack(self) -> <(U5, U38) as BitPack>::Packed

fn unpack(packed: <(U5, U38) as BitPack>::Packed) -> (U5, U38)

impl BitPack for (U15, U14)

type Packed = U29

fn pack(self) -> <(U15, U14) as BitPack>::Packed

fn unpack(packed: <(U15, U14) as BitPack>::Packed) -> (U15, U14)

impl BitPack for (U35, U12)

type Packed = U47

fn pack(self) -> <(U35, U12) as BitPack>::Packed

fn unpack(packed: <(U35, U12) as BitPack>::Packed) -> (U35, U12)

impl BitPack for (U29, U11)

type Packed = U40

fn pack(self) -> <(U29, U11) as BitPack>::Packed

fn unpack(packed: <(U29, U11) as BitPack>::Packed) -> (U29, U11)

impl BitPack for (U7, U30)

type Packed = U37

fn pack(self) -> <(U7, U30) as BitPack>::Packed

fn unpack(packed: <(U7, U30) as BitPack>::Packed) -> (U7, U30)

impl BitPack for (U22, U37)

type Packed = U59

fn pack(self) -> <(U22, U37) as BitPack>::Packed

fn unpack(packed: <(U22, U37) as BitPack>::Packed) -> (U22, U37)

impl BitPack for (U12, U39)

type Packed = U51

fn pack(self) -> <(U12, U39) as BitPack>::Packed

fn unpack(packed: <(U12, U39) as BitPack>::Packed) -> (U12, U39)

impl BitPack for (U17, U31)

type Packed = U48

fn pack(self) -> <(U17, U31) as BitPack>::Packed

fn unpack(packed: <(U17, U31) as BitPack>::Packed) -> (U17, U31)

impl BitPack for (U31, U29)

type Packed = U60

fn pack(self) -> <(U31, U29) as BitPack>::Packed

fn unpack(packed: <(U31, U29) as BitPack>::Packed) -> (U31, U29)

impl BitPack for (U22, U7)

type Packed = U29

fn pack(self) -> <(U22, U7) as BitPack>::Packed

fn unpack(packed: <(U22, U7) as BitPack>::Packed) -> (U22, U7)

impl BitPack for (U34, u16)

type Packed = U50

fn pack(self) -> <(U34, u16) as BitPack>::Packed

fn unpack(packed: <(U34, u16) as BitPack>::Packed) -> (U34, u16)

impl BitPack for (U17, U35)

type Packed = U52

fn pack(self) -> <(U17, U35) as BitPack>::Packed

fn unpack(packed: <(U17, U35) as BitPack>::Packed) -> (U17, U35)

impl BitPack for (U19, U35)

type Packed = U54

fn pack(self) -> <(U19, U35) as BitPack>::Packed

fn unpack(packed: <(U19, U35) as BitPack>::Packed) -> (U19, U35)

impl BitPack for (U9, U53)

type Packed = U62

fn pack(self) -> <(U9, U53) as BitPack>::Packed

fn unpack(packed: <(U9, U53) as BitPack>::Packed) -> (U9, U53)

impl BitPack for (U1, U1)

type Packed = U2

fn pack(self) -> <(U1, U1) as BitPack>::Packed

fn unpack(packed: <(U1, U1) as BitPack>::Packed) -> (U1, U1)

impl BitPack for (U51, U3)

type Packed = U54

fn pack(self) -> <(U51, U3) as BitPack>::Packed

fn unpack(packed: <(U51, U3) as BitPack>::Packed) -> (U51, U3)

impl BitPack for (u8, U12)

type Packed = U20

fn pack(self) -> <(u8, U12) as BitPack>::Packed

fn unpack(packed: <(u8, U12) as BitPack>::Packed) -> (u8, U12)

impl BitPack for (U19, U37)

type Packed = U56

fn pack(self) -> <(U19, U37) as BitPack>::Packed

fn unpack(packed: <(U19, U37) as BitPack>::Packed) -> (U19, U37)

impl BitPack for (U4, U5)

type Packed = U9

fn pack(self) -> <(U4, U5) as BitPack>::Packed

fn unpack(packed: <(U4, U5) as BitPack>::Packed) -> (U4, U5)

impl BitPack for (U6, U46)

type Packed = U52

fn pack(self) -> <(U6, U46) as BitPack>::Packed

fn unpack(packed: <(U6, U46) as BitPack>::Packed) -> (U6, U46)

impl BitPack for (U15, u32)

type Packed = U47

fn pack(self) -> <(U15, u32) as BitPack>::Packed

fn unpack(packed: <(U15, u32) as BitPack>::Packed) -> (U15, u32)

impl BitPack for (U3, U47)

type Packed = U50

fn pack(self) -> <(U3, U47) as BitPack>::Packed

fn unpack(packed: <(U3, U47) as BitPack>::Packed) -> (U3, U47)

impl BitPack for (U17, U9)

type Packed = U26

fn pack(self) -> <(U17, U9) as BitPack>::Packed

fn unpack(packed: <(U17, U9) as BitPack>::Packed) -> (U17, U9)

impl BitPack for (U2, U24)

type Packed = U26

fn pack(self) -> <(U2, U24) as BitPack>::Packed

fn unpack(packed: <(U2, U24) as BitPack>::Packed) -> (U2, U24)

impl BitPack for (U19, U9)

type Packed = U28

fn pack(self) -> <(U19, U9) as BitPack>::Packed

fn unpack(packed: <(U19, U9) as BitPack>::Packed) -> (U19, U9)

impl BitPack for (U10, U45)

type Packed = U55

fn pack(self) -> <(U10, U45) as BitPack>::Packed

fn unpack(packed: <(U10, U45) as BitPack>::Packed) -> (U10, U45)

impl BitPack for (U2, U41)

type Packed = U43

fn pack(self) -> <(U2, U41) as BitPack>::Packed

fn unpack(packed: <(U2, U41) as BitPack>::Packed) -> (U2, U41)

impl BitPack for (U20, U29)

type Packed = U49

fn pack(self) -> <(U20, U29) as BitPack>::Packed

fn unpack(packed: <(U20, U29) as BitPack>::Packed) -> (U20, U29)

impl BitPack for (U18, U12)

type Packed = U30

fn pack(self) -> <(U18, U12) as BitPack>::Packed

fn unpack(packed: <(U18, U12) as BitPack>::Packed) -> (U18, U12)

impl BitPack for (U36, U2)

type Packed = U38

fn pack(self) -> <(U36, U2) as BitPack>::Packed

fn unpack(packed: <(U36, U2) as BitPack>::Packed) -> (U36, U2)

impl BitPack for (U11, U47)

type Packed = U58

fn pack(self) -> <(U11, U47) as BitPack>::Packed

fn unpack(packed: <(U11, U47) as BitPack>::Packed) -> (U11, U47)

impl BitPack for (U1, U60)

type Packed = U61

fn pack(self) -> <(U1, U60) as BitPack>::Packed

fn unpack(packed: <(U1, U60) as BitPack>::Packed) -> (U1, U60)

impl BitPack for (U53, U9)

type Packed = U62

fn pack(self) -> <(U53, U9) as BitPack>::Packed

fn unpack(packed: <(U53, U9) as BitPack>::Packed) -> (U53, U9)

impl BitPack for (U41, U2)

type Packed = U43

fn pack(self) -> <(U41, U2) as BitPack>::Packed

fn unpack(packed: <(U41, U2) as BitPack>::Packed) -> (U41, U2)

impl BitPack for (U4, U46)

type Packed = U50

fn pack(self) -> <(U4, U46) as BitPack>::Packed

fn unpack(packed: <(U4, U46) as BitPack>::Packed) -> (U4, U46)

impl<T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T16, <(T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T16, <(T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U4, U9)

type Packed = U13

fn pack(self) -> <(U4, U9) as BitPack>::Packed

fn unpack(packed: <(U4, U9) as BitPack>::Packed) -> (U4, U9)

impl BitPack for (u16, U11)

type Packed = U27

fn pack(self) -> <(u16, U11) as BitPack>::Packed

fn unpack(packed: <(u16, U11) as BitPack>::Packed) -> (u16, U11)

impl BitPack for (U3, U15)

type Packed = U18

fn pack(self) -> <(U3, U15) as BitPack>::Packed

fn unpack(packed: <(U3, U15) as BitPack>::Packed) -> (U3, U15)

impl BitPack for (U5, u16)

type Packed = U21

fn pack(self) -> <(U5, u16) as BitPack>::Packed

fn unpack(packed: <(U5, u16) as BitPack>::Packed) -> (U5, u16)

impl BitPack for (U20, U14)

type Packed = U34

fn pack(self) -> <(U20, U14) as BitPack>::Packed

fn unpack(packed: <(U20, U14) as BitPack>::Packed) -> (U20, U14)

impl<T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T18, <(T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T18, <(T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl<T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T20, <(T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T20, <(T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U6, U50)

type Packed = U56

fn pack(self) -> <(U6, U50) as BitPack>::Packed

fn unpack(packed: <(U6, U50) as BitPack>::Packed) -> (U6, U50)

impl BitPack for (u8, U9)

type Packed = U17

fn pack(self) -> <(u8, U9) as BitPack>::Packed

fn unpack(packed: <(u8, U9) as BitPack>::Packed) -> (u8, U9)

impl BitPack for (U37, U26)

type Packed = U63

fn pack(self) -> <(U37, U26) as BitPack>::Packed

fn unpack(packed: <(U37, U26) as BitPack>::Packed) -> (U37, U26)

impl BitPack for (U11, U37)

type Packed = U48

fn pack(self) -> <(U11, U37) as BitPack>::Packed

fn unpack(packed: <(U11, U37) as BitPack>::Packed) -> (U11, U37)

impl BitPack for (U39, U10)

type Packed = U49

fn pack(self) -> <(U39, U10) as BitPack>::Packed

fn unpack(packed: <(U39, U10) as BitPack>::Packed) -> (U39, U10)

impl BitPack for (U31, U2)

type Packed = U33

fn pack(self) -> <(U31, U2) as BitPack>::Packed

fn unpack(packed: <(U31, U2) as BitPack>::Packed) -> (U31, U2)

impl BitPack for (U10, U35)

type Packed = U45

fn pack(self) -> <(U10, U35) as BitPack>::Packed

fn unpack(packed: <(U10, U35) as BitPack>::Packed) -> (U10, U35)

impl BitPack for (U18, U4)

type Packed = U22

fn pack(self) -> <(U18, U4) as BitPack>::Packed

fn unpack(packed: <(U18, U4) as BitPack>::Packed) -> (U18, U4)

impl BitPack for (U28, U6)

type Packed = U34

fn pack(self) -> <(U28, U6) as BitPack>::Packed

fn unpack(packed: <(U28, U6) as BitPack>::Packed) -> (U28, U6)

impl BitPack for (U25, U1)

type Packed = U26

fn pack(self) -> <(U25, U1) as BitPack>::Packed

fn unpack(packed: <(U25, U1) as BitPack>::Packed) -> (U25, U1)

impl BitPack for (U14, u8)

type Packed = U22

fn pack(self) -> <(U14, u8) as BitPack>::Packed

fn unpack(packed: <(U14, u8) as BitPack>::Packed) -> (U14, u8)

impl BitPack for (U12, U11)

type Packed = U23

fn pack(self) -> <(U12, U11) as BitPack>::Packed

fn unpack(packed: <(U12, U11) as BitPack>::Packed) -> (U12, U11)

impl BitPack for (U15, U34)

type Packed = U49

fn pack(self) -> <(U15, U34) as BitPack>::Packed

fn unpack(packed: <(U15, U34) as BitPack>::Packed) -> (U15, U34)

impl BitPack for (U7, U2)

type Packed = U9

fn pack(self) -> <(U7, U2) as BitPack>::Packed

fn unpack(packed: <(U7, U2) as BitPack>::Packed) -> (U7, U2)

impl BitPack for (U39, U19)

type Packed = U58

fn pack(self) -> <(U39, U19) as BitPack>::Packed

fn unpack(packed: <(U39, U19) as BitPack>::Packed) -> (U39, U19)

impl BitPack for (u16, U28)

type Packed = U44

fn pack(self) -> <(u16, U28) as BitPack>::Packed

fn unpack(packed: <(u16, U28) as BitPack>::Packed) -> (u16, U28)

impl BitPack for (U38, U19)

type Packed = U57

fn pack(self) -> <(U38, U19) as BitPack>::Packed

fn unpack(packed: <(U38, U19) as BitPack>::Packed) -> (U38, U19)

impl BitPack for (U2, U34)

type Packed = U36

fn pack(self) -> <(U2, U34) as BitPack>::Packed

fn unpack(packed: <(U2, U34) as BitPack>::Packed) -> (U2, U34)

impl BitPack for (U13, U17)

type Packed = U30

fn pack(self) -> <(U13, U17) as BitPack>::Packed

fn unpack(packed: <(U13, U17) as BitPack>::Packed) -> (U13, U17)

impl BitPack for (U1, U36)

type Packed = U37

fn pack(self) -> <(U1, U36) as BitPack>::Packed

fn unpack(packed: <(U1, U36) as BitPack>::Packed) -> (U1, U36)

impl BitPack for (U58, U2)

type Packed = U60

fn pack(self) -> <(U58, U2) as BitPack>::Packed

fn unpack(packed: <(U58, U2) as BitPack>::Packed) -> (U58, U2)

impl BitPack for (U23, U21)

type Packed = U44

fn pack(self) -> <(U23, U21) as BitPack>::Packed

fn unpack(packed: <(U23, U21) as BitPack>::Packed) -> (U23, U21)

impl BitPack for (U13, U13)

type Packed = U26

fn pack(self) -> <(U13, U13) as BitPack>::Packed

fn unpack(packed: <(U13, U13) as BitPack>::Packed) -> (U13, U13)

impl BitPack for (U15, U42)

type Packed = U57

fn pack(self) -> <(U15, U42) as BitPack>::Packed

fn unpack(packed: <(U15, U42) as BitPack>::Packed) -> (U15, U42)

impl BitPack for (U1, U4)

type Packed = U5

fn pack(self) -> <(U1, U4) as BitPack>::Packed

fn unpack(packed: <(U1, U4) as BitPack>::Packed) -> (U1, U4)

impl BitPack for (U13, u32)

type Packed = U45

fn pack(self) -> <(U13, u32) as BitPack>::Packed

fn unpack(packed: <(U13, u32) as BitPack>::Packed) -> (U13, u32)

impl BitPack for (U7, U42)

type Packed = U49

fn pack(self) -> <(U7, U42) as BitPack>::Packed

fn unpack(packed: <(U7, U42) as BitPack>::Packed) -> (U7, U42)

impl BitPack for (U10, U22)

type Packed = u32

fn pack(self) -> <(U10, U22) as BitPack>::Packed

fn unpack(packed: <(U10, U22) as BitPack>::Packed) -> (U10, U22)

impl BitPack for (U15, U12)

type Packed = U27

fn pack(self) -> <(U15, U12) as BitPack>::Packed

fn unpack(packed: <(U15, U12) as BitPack>::Packed) -> (U15, U12)

impl<T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T22, <(T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T22, <(T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U27, U13)

type Packed = U40

fn pack(self) -> <(U27, U13) as BitPack>::Packed

fn unpack(packed: <(U27, U13) as BitPack>::Packed) -> (U27, U13)

impl BitPack for (U9, U30)

type Packed = U39

fn pack(self) -> <(U9, U30) as BitPack>::Packed

fn unpack(packed: <(U9, U30) as BitPack>::Packed) -> (U9, U30)

impl BitPack for (U62, U1)

type Packed = U63

fn pack(self) -> <(U62, U1) as BitPack>::Packed

fn unpack(packed: <(U62, U1) as BitPack>::Packed) -> (U62, U1)

impl BitPack for (U23, U41)

type Packed = u64

fn pack(self) -> <(U23, U41) as BitPack>::Packed

fn unpack(packed: <(U23, U41) as BitPack>::Packed) -> (U23, U41)

impl BitPack for (U4, U35)

type Packed = U39

fn pack(self) -> <(U4, U35) as BitPack>::Packed

fn unpack(packed: <(U4, U35) as BitPack>::Packed) -> (U4, U35)

impl BitPack for (U2, U3)

type Packed = U5

fn pack(self) -> <(U2, U3) as BitPack>::Packed

fn unpack(packed: <(U2, U3) as BitPack>::Packed) -> (U2, U3)

impl BitPack for (U4, U26)

type Packed = U30

fn pack(self) -> <(U4, U26) as BitPack>::Packed

fn unpack(packed: <(U4, U26) as BitPack>::Packed) -> (U4, U26)

impl BitPack for (U10, U4)

type Packed = U14

fn pack(self) -> <(U10, U4) as BitPack>::Packed

fn unpack(packed: <(U10, U4) as BitPack>::Packed) -> (U10, U4)

impl BitPack for (U12, U7)

type Packed = U19

fn pack(self) -> <(U12, U7) as BitPack>::Packed

fn unpack(packed: <(U12, U7) as BitPack>::Packed) -> (U12, U7)

impl BitPack for (U31, u8)

type Packed = U39

fn pack(self) -> <(U31, u8) as BitPack>::Packed

fn unpack(packed: <(U31, u8) as BitPack>::Packed) -> (U31, u8)

impl BitPack for (U30, U21)

type Packed = U51

fn pack(self) -> <(U30, U21) as BitPack>::Packed

fn unpack(packed: <(U30, U21) as BitPack>::Packed) -> (U30, U21)

impl BitPack for (U39, U18)

type Packed = U57

fn pack(self) -> <(U39, U18) as BitPack>::Packed

fn unpack(packed: <(U39, U18) as BitPack>::Packed) -> (U39, U18)

impl BitPack for (U19, U6)

type Packed = U25

fn pack(self) -> <(U19, U6) as BitPack>::Packed

fn unpack(packed: <(U19, U6) as BitPack>::Packed) -> (U19, U6)

impl BitPack for (U14, U45)

type Packed = U59

fn pack(self) -> <(U14, U45) as BitPack>::Packed

fn unpack(packed: <(U14, U45) as BitPack>::Packed) -> (U14, U45)

impl BitPack for (U7, U22)

type Packed = U29

fn pack(self) -> <(U7, U22) as BitPack>::Packed

fn unpack(packed: <(U7, U22) as BitPack>::Packed) -> (U7, U22)

impl BitPack for (U2, U42)

type Packed = U44

fn pack(self) -> <(U2, U42) as BitPack>::Packed

fn unpack(packed: <(U2, U42) as BitPack>::Packed) -> (U2, U42)

impl BitPack for (U5, U21)

type Packed = U26

fn pack(self) -> <(U5, U21) as BitPack>::Packed

fn unpack(packed: <(U5, U21) as BitPack>::Packed) -> (U5, U21)

impl BitPack for (U38, U24)

type Packed = U62

fn pack(self) -> <(U38, U24) as BitPack>::Packed

fn unpack(packed: <(U38, U24) as BitPack>::Packed) -> (U38, U24)

impl BitPack for (u32, U13)

type Packed = U45

fn pack(self) -> <(u32, U13) as BitPack>::Packed

fn unpack(packed: <(u32, U13) as BitPack>::Packed) -> (u32, U13)

impl BitPack for (U36, U26)

type Packed = U62

fn pack(self) -> <(U36, U26) as BitPack>::Packed

fn unpack(packed: <(U36, U26) as BitPack>::Packed) -> (U36, U26)

impl BitPack for (U4, U58)

type Packed = U62

fn pack(self) -> <(U4, U58) as BitPack>::Packed

fn unpack(packed: <(U4, U58) as BitPack>::Packed) -> (U4, U58)

impl BitPack for (U30, U4)

type Packed = U34

fn pack(self) -> <(U30, U4) as BitPack>::Packed

fn unpack(packed: <(U30, U4) as BitPack>::Packed) -> (U30, U4)

impl BitPack for (U5, U20)

type Packed = U25

fn pack(self) -> <(U5, U20) as BitPack>::Packed

fn unpack(packed: <(U5, U20) as BitPack>::Packed) -> (U5, U20)

impl BitPack for (U12, U45)

type Packed = U57

fn pack(self) -> <(U12, U45) as BitPack>::Packed

fn unpack(packed: <(U12, U45) as BitPack>::Packed) -> (U12, U45)

impl BitPack for (U31, U30)

type Packed = U61

fn pack(self) -> <(U31, U30) as BitPack>::Packed

fn unpack(packed: <(U31, U30) as BitPack>::Packed) -> (U31, U30)

impl BitPack for (U1, U29)

type Packed = U30

fn pack(self) -> <(U1, U29) as BitPack>::Packed

fn unpack(packed: <(U1, U29) as BitPack>::Packed) -> (U1, U29)

impl BitPack for (U20, U37)

type Packed = U57

fn pack(self) -> <(U20, U37) as BitPack>::Packed

fn unpack(packed: <(U20, U37) as BitPack>::Packed) -> (U20, U37)

impl BitPack for (U22, U40)

type Packed = U62

fn pack(self) -> <(U22, U40) as BitPack>::Packed

fn unpack(packed: <(U22, U40) as BitPack>::Packed) -> (U22, U40)

impl BitPack for (U14, U7)

type Packed = U21

fn pack(self) -> <(U14, U7) as BitPack>::Packed

fn unpack(packed: <(U14, U7) as BitPack>::Packed) -> (U14, U7)

impl BitPack for (U50, u8)

type Packed = U58

fn pack(self) -> <(U50, u8) as BitPack>::Packed

fn unpack(packed: <(U50, u8) as BitPack>::Packed) -> (U50, u8)

impl BitPack for (U6, U40)

type Packed = U46

fn pack(self) -> <(U6, U40) as BitPack>::Packed

fn unpack(packed: <(U6, U40) as BitPack>::Packed) -> (U6, U40)

impl BitPack for (U11, U1)

type Packed = U12

fn pack(self) -> <(U11, U1) as BitPack>::Packed

fn unpack(packed: <(U11, U1) as BitPack>::Packed) -> (U11, U1)

impl BitPack for (u16, U30)

type Packed = U46

fn pack(self) -> <(u16, U30) as BitPack>::Packed

fn unpack(packed: <(u16, U30) as BitPack>::Packed) -> (u16, U30)

impl BitPack for (U35, U26)

type Packed = U61

fn pack(self) -> <(U35, U26) as BitPack>::Packed

fn unpack(packed: <(U35, U26) as BitPack>::Packed) -> (U35, U26)

impl BitPack for (U12, U12)

type Packed = U24

fn pack(self) -> <(U12, U12) as BitPack>::Packed

fn unpack(packed: <(U12, U12) as BitPack>::Packed) -> (U12, U12)

impl BitPack for (U3, U6)

type Packed = U9

fn pack(self) -> <(U3, U6) as BitPack>::Packed

fn unpack(packed: <(U3, U6) as BitPack>::Packed) -> (U3, U6)

impl BitPack for (U45, U14)

type Packed = U59

fn pack(self) -> <(U45, U14) as BitPack>::Packed

fn unpack(packed: <(U45, U14) as BitPack>::Packed) -> (U45, U14)

impl BitPack for (U47, U2)

type Packed = U49

fn pack(self) -> <(U47, U2) as BitPack>::Packed

fn unpack(packed: <(U47, U2) as BitPack>::Packed) -> (U47, U2)

impl BitPack for (U30, U6)

type Packed = U36

fn pack(self) -> <(U30, U6) as BitPack>::Packed

fn unpack(packed: <(U30, U6) as BitPack>::Packed) -> (U30, U6)

impl BitPack for (U10, U10)

type Packed = U20

fn pack(self) -> <(U10, U10) as BitPack>::Packed

fn unpack(packed: <(U10, U10) as BitPack>::Packed) -> (U10, U10)

impl<T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T33, <(T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T33, <(T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U35, U7)

type Packed = U42

fn pack(self) -> <(U35, U7) as BitPack>::Packed

fn unpack(packed: <(U35, U7) as BitPack>::Packed) -> (U35, U7)

impl BitPack for (U4, U53)

type Packed = U57

fn pack(self) -> <(U4, U53) as BitPack>::Packed

fn unpack(packed: <(U4, U53) as BitPack>::Packed) -> (U4, U53)

impl BitPack for (u16, U6)

type Packed = U22

fn pack(self) -> <(u16, U6) as BitPack>::Packed

fn unpack(packed: <(u16, U6) as BitPack>::Packed) -> (u16, U6)

impl BitPack for (U17, U14)

type Packed = U31

fn pack(self) -> <(U17, U14) as BitPack>::Packed

fn unpack(packed: <(U17, U14) as BitPack>::Packed) -> (U17, U14)

impl BitPack for (U20, U34)

type Packed = U54

fn pack(self) -> <(U20, U34) as BitPack>::Packed

fn unpack(packed: <(U20, U34) as BitPack>::Packed) -> (U20, U34)

impl BitPack for (U23, U17)

type Packed = U40

fn pack(self) -> <(U23, U17) as BitPack>::Packed

fn unpack(packed: <(U23, U17) as BitPack>::Packed) -> (U23, U17)

impl BitPack for (U27, U4)

type Packed = U31

fn pack(self) -> <(U27, U4) as BitPack>::Packed

fn unpack(packed: <(U27, U4) as BitPack>::Packed) -> (U27, U4)

impl BitPack for (U9, U43)

type Packed = U52

fn pack(self) -> <(U9, U43) as BitPack>::Packed

fn unpack(packed: <(U9, U43) as BitPack>::Packed) -> (U9, U43)

impl BitPack for (U43, u8)

type Packed = U51

fn pack(self) -> <(U43, u8) as BitPack>::Packed

fn unpack(packed: <(U43, u8) as BitPack>::Packed) -> (U43, u8)

impl BitPack for (U21, U37)

type Packed = U58

fn pack(self) -> <(U21, U37) as BitPack>::Packed

fn unpack(packed: <(U21, U37) as BitPack>::Packed) -> (U21, U37)

impl BitPack for (U7, U31)

type Packed = U38

fn pack(self) -> <(U7, U31) as BitPack>::Packed

fn unpack(packed: <(U7, U31) as BitPack>::Packed) -> (U7, U31)

impl BitPack for (u16, U15)

type Packed = U31

fn pack(self) -> <(u16, U15) as BitPack>::Packed

fn unpack(packed: <(u16, U15) as BitPack>::Packed) -> (u16, U15)

impl BitPack for (U24, U38)

type Packed = U62

fn pack(self) -> <(U24, U38) as BitPack>::Packed

fn unpack(packed: <(U24, U38) as BitPack>::Packed) -> (U24, U38)

impl BitPack for (U10, U5)

type Packed = U15

fn pack(self) -> <(U10, U5) as BitPack>::Packed

fn unpack(packed: <(U10, U5) as BitPack>::Packed) -> (U10, U5)

impl BitPack for (U41, U19)

type Packed = U60

fn pack(self) -> <(U41, U19) as BitPack>::Packed

fn unpack(packed: <(U41, U19) as BitPack>::Packed) -> (U41, U19)

impl BitPack for (U42, U19)

type Packed = U61

fn pack(self) -> <(U42, U19) as BitPack>::Packed

fn unpack(packed: <(U42, U19) as BitPack>::Packed) -> (U42, U19)

impl BitPack for (U3, U59)

type Packed = U62

fn pack(self) -> <(U3, U59) as BitPack>::Packed

fn unpack(packed: <(U3, U59) as BitPack>::Packed) -> (U3, U59)

impl<T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T55, <(T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T55, <(T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U23, u16)

type Packed = U39

fn pack(self) -> <(U23, u16) as BitPack>::Packed

fn unpack(packed: <(U23, u16) as BitPack>::Packed) -> (U23, u16)

impl BitPack for (U15, U49)

type Packed = u64

fn pack(self) -> <(U15, U49) as BitPack>::Packed

fn unpack(packed: <(U15, U49) as BitPack>::Packed) -> (U15, U49)

impl BitPack for (U20, U22)

type Packed = U42

fn pack(self) -> <(U20, U22) as BitPack>::Packed

fn unpack(packed: <(U20, U22) as BitPack>::Packed) -> (U20, U22)

impl BitPack for (U30, U27)

type Packed = U57

fn pack(self) -> <(U30, U27) as BitPack>::Packed

fn unpack(packed: <(U30, U27) as BitPack>::Packed) -> (U30, U27)

impl BitPack for (U37, U7)

type Packed = U44

fn pack(self) -> <(U37, U7) as BitPack>::Packed

fn unpack(packed: <(U37, U7) as BitPack>::Packed) -> (U37, U7)

impl BitPack for (U1, U45)

type Packed = U46

fn pack(self) -> <(U1, U45) as BitPack>::Packed

fn unpack(packed: <(U1, U45) as BitPack>::Packed) -> (U1, U45)

impl BitPack for (U6, U15)

type Packed = U21

fn pack(self) -> <(U6, U15) as BitPack>::Packed

fn unpack(packed: <(U6, U15) as BitPack>::Packed) -> (U6, U15)

impl BitPack for (U4, U55)

type Packed = U59

fn pack(self) -> <(U4, U55) as BitPack>::Packed

fn unpack(packed: <(U4, U55) as BitPack>::Packed) -> (U4, U55)

impl BitPack for (U7, U36)

type Packed = U43

fn pack(self) -> <(U7, U36) as BitPack>::Packed

fn unpack(packed: <(U7, U36) as BitPack>::Packed) -> (U7, U36)

impl BitPack for (U24, U23)

type Packed = U47

fn pack(self) -> <(U24, U23) as BitPack>::Packed

fn unpack(packed: <(U24, U23) as BitPack>::Packed) -> (U24, U23)

impl BitPack for (U43, U15)

type Packed = U58

fn pack(self) -> <(U43, U15) as BitPack>::Packed

fn unpack(packed: <(U43, U15) as BitPack>::Packed) -> (U43, U15)

impl<T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T47, <(T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T47, <(T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U33, U15)

type Packed = U48

fn pack(self) -> <(U33, U15) as BitPack>::Packed

fn unpack(packed: <(U33, U15) as BitPack>::Packed) -> (U33, U15)

impl BitPack for (U6, U5)

type Packed = U11

fn pack(self) -> <(U6, U5) as BitPack>::Packed

fn unpack(packed: <(U6, U5) as BitPack>::Packed) -> (U6, U5)

impl BitPack for (U13, U29)

type Packed = U42

fn pack(self) -> <(U13, U29) as BitPack>::Packed

fn unpack(packed: <(U13, U29) as BitPack>::Packed) -> (U13, U29)

impl BitPack for (U9, U35)

type Packed = U44

fn pack(self) -> <(U9, U35) as BitPack>::Packed

fn unpack(packed: <(U9, U35) as BitPack>::Packed) -> (U9, U35)

impl BitPack for (U1, u16)

type Packed = U17

fn pack(self) -> <(U1, u16) as BitPack>::Packed

fn unpack(packed: <(U1, u16) as BitPack>::Packed) -> (U1, u16)

impl BitPack for (U7, U11)

type Packed = U18

fn pack(self) -> <(U7, U11) as BitPack>::Packed

fn unpack(packed: <(U7, U11) as BitPack>::Packed) -> (U7, U11)

impl BitPack for (U22, U31)

type Packed = U53

fn pack(self) -> <(U22, U31) as BitPack>::Packed

fn unpack(packed: <(U22, U31) as BitPack>::Packed) -> (U22, U31)

impl BitPack for (U22, U26)

type Packed = U48

fn pack(self) -> <(U22, U26) as BitPack>::Packed

fn unpack(packed: <(U22, U26) as BitPack>::Packed) -> (U22, U26)

impl BitPack for (U18, U3)

type Packed = U21

fn pack(self) -> <(U18, U3) as BitPack>::Packed

fn unpack(packed: <(U18, U3) as BitPack>::Packed) -> (U18, U3)

impl BitPack for (U35, U3)

type Packed = U38

fn pack(self) -> <(U35, U3) as BitPack>::Packed

fn unpack(packed: <(U35, U3) as BitPack>::Packed) -> (U35, U3)

impl BitPack for (U45, u8)

type Packed = U53

fn pack(self) -> <(U45, u8) as BitPack>::Packed

fn unpack(packed: <(U45, u8) as BitPack>::Packed) -> (U45, u8)

impl BitPack for (U28, U10)

type Packed = U38

fn pack(self) -> <(U28, U10) as BitPack>::Packed

fn unpack(packed: <(U28, U10) as BitPack>::Packed) -> (U28, U10)

impl BitPack for (U11, U43)

type Packed = U54

fn pack(self) -> <(U11, U43) as BitPack>::Packed

fn unpack(packed: <(U11, U43) as BitPack>::Packed) -> (U11, U43)

impl BitPack for (U55, U3)

type Packed = U58

fn pack(self) -> <(U55, U3) as BitPack>::Packed

fn unpack(packed: <(U55, U3) as BitPack>::Packed) -> (U55, U3)

impl BitPack for (U6, U29)

type Packed = U35

fn pack(self) -> <(U6, U29) as BitPack>::Packed

fn unpack(packed: <(U6, U29) as BitPack>::Packed) -> (U6, U29)

impl BitPack for (U21, U26)

type Packed = U47

fn pack(self) -> <(U21, U26) as BitPack>::Packed

fn unpack(packed: <(U21, U26) as BitPack>::Packed) -> (U21, U26)

impl BitPack for (U51, U10)

type Packed = U61

fn pack(self) -> <(U51, U10) as BitPack>::Packed

fn unpack(packed: <(U51, U10) as BitPack>::Packed) -> (U51, U10)

impl BitPack for (U25, U31)

type Packed = U56

fn pack(self) -> <(U25, U31) as BitPack>::Packed

fn unpack(packed: <(U25, U31) as BitPack>::Packed) -> (U25, U31)

impl BitPack for (U9, U13)

type Packed = U22

fn pack(self) -> <(U9, U13) as BitPack>::Packed

fn unpack(packed: <(U9, U13) as BitPack>::Packed) -> (U9, U13)

impl BitPack for (U4, U3)

type Packed = U7

fn pack(self) -> <(U4, U3) as BitPack>::Packed

fn unpack(packed: <(U4, U3) as BitPack>::Packed) -> (U4, U3)

impl BitPack for (U7, U5)

type Packed = U12

fn pack(self) -> <(U7, U5) as BitPack>::Packed

fn unpack(packed: <(U7, U5) as BitPack>::Packed) -> (U7, U5)

impl BitPack for (U6, U41)

type Packed = U47

fn pack(self) -> <(U6, U41) as BitPack>::Packed

fn unpack(packed: <(U6, U41) as BitPack>::Packed) -> (U6, U41)

impl BitPack for (U5, U6)

type Packed = U11

fn pack(self) -> <(U5, U6) as BitPack>::Packed

fn unpack(packed: <(U5, U6) as BitPack>::Packed) -> (U5, U6)

impl BitPack for (U35, U11)

type Packed = U46

fn pack(self) -> <(U35, U11) as BitPack>::Packed

fn unpack(packed: <(U35, U11) as BitPack>::Packed) -> (U35, U11)

impl BitPack for (U17, U25)

type Packed = U42

fn pack(self) -> <(U17, U25) as BitPack>::Packed

fn unpack(packed: <(U17, U25) as BitPack>::Packed) -> (U17, U25)

impl BitPack for (U7, U51)

type Packed = U58

fn pack(self) -> <(U7, U51) as BitPack>::Packed

fn unpack(packed: <(U7, U51) as BitPack>::Packed) -> (U7, U51)

impl BitPack for (U3, U20)

type Packed = U23

fn pack(self) -> <(U3, U20) as BitPack>::Packed

fn unpack(packed: <(U3, U20) as BitPack>::Packed) -> (U3, U20)

impl BitPack for (U36, U4)

type Packed = U40

fn pack(self) -> <(U36, U4) as BitPack>::Packed

fn unpack(packed: <(U36, U4) as BitPack>::Packed) -> (U36, U4)

impl BitPack for (U47, U14)

type Packed = U61

fn pack(self) -> <(U47, U14) as BitPack>::Packed

fn unpack(packed: <(U47, U14) as BitPack>::Packed) -> (U47, U14)

impl BitPack for (U29, U30)

type Packed = U59

fn pack(self) -> <(U29, U30) as BitPack>::Packed

fn unpack(packed: <(U29, U30) as BitPack>::Packed) -> (U29, U30)

impl BitPack for (U45, U4)

type Packed = U49

fn pack(self) -> <(U45, U4) as BitPack>::Packed

fn unpack(packed: <(U45, U4) as BitPack>::Packed) -> (U45, U4)

impl BitPack for (U20, U38)

type Packed = U58

fn pack(self) -> <(U20, U38) as BitPack>::Packed

fn unpack(packed: <(U20, U38) as BitPack>::Packed) -> (U20, U38)

impl BitPack for (u32, U19)

type Packed = U51

fn pack(self) -> <(u32, U19) as BitPack>::Packed

fn unpack(packed: <(u32, U19) as BitPack>::Packed) -> (u32, U19)

impl BitPack for (U12, U18)

type Packed = U30

fn pack(self) -> <(U12, U18) as BitPack>::Packed

fn unpack(packed: <(U12, U18) as BitPack>::Packed) -> (U12, U18)

impl BitPack for (U7, U27)

type Packed = U34

fn pack(self) -> <(U7, U27) as BitPack>::Packed

fn unpack(packed: <(U7, U27) as BitPack>::Packed) -> (U7, U27)

impl BitPack for (U43, U1)

type Packed = U44

fn pack(self) -> <(U43, U1) as BitPack>::Packed

fn unpack(packed: <(U43, U1) as BitPack>::Packed) -> (U43, U1)

impl BitPack for (u8, u32)

type Packed = U40

fn pack(self) -> <(u8, u32) as BitPack>::Packed

fn unpack(packed: <(u8, u32) as BitPack>::Packed) -> (u8, u32)

impl BitPack for (u8, U15)

type Packed = U23

fn pack(self) -> <(u8, U15) as BitPack>::Packed

fn unpack(packed: <(u8, U15) as BitPack>::Packed) -> (u8, U15)

impl BitPack for (U6, U55)

type Packed = U61

fn pack(self) -> <(U6, U55) as BitPack>::Packed

fn unpack(packed: <(U6, U55) as BitPack>::Packed) -> (U6, U55)

impl BitPack for (U60, U4)

type Packed = u64

fn pack(self) -> <(U60, U4) as BitPack>::Packed

fn unpack(packed: <(U60, U4) as BitPack>::Packed) -> (U60, U4)

impl BitPack for (U4, U42)

type Packed = U46

fn pack(self) -> <(U4, U42) as BitPack>::Packed

fn unpack(packed: <(U4, U42) as BitPack>::Packed) -> (U4, U42)

impl BitPack for (U19, U41)

type Packed = U60

fn pack(self) -> <(U19, U41) as BitPack>::Packed

fn unpack(packed: <(U19, U41) as BitPack>::Packed) -> (U19, U41)

impl BitPack for (U14, U48)

type Packed = U62

fn pack(self) -> <(U14, U48) as BitPack>::Packed

fn unpack(packed: <(U14, U48) as BitPack>::Packed) -> (U14, U48)

impl BitPack for (U6, U3)

type Packed = U9

fn pack(self) -> <(U6, U3) as BitPack>::Packed

fn unpack(packed: <(U6, U3) as BitPack>::Packed) -> (U6, U3)

impl BitPack for (U2, U35)

type Packed = U37

fn pack(self) -> <(U2, U35) as BitPack>::Packed

fn unpack(packed: <(U2, U35) as BitPack>::Packed) -> (U2, U35)

impl BitPack for (U28, U9)

type Packed = U37

fn pack(self) -> <(U28, U9) as BitPack>::Packed

fn unpack(packed: <(U28, U9) as BitPack>::Packed) -> (U28, U9)

impl BitPack for (U50, U2)

type Packed = U52

fn pack(self) -> <(U50, U2) as BitPack>::Packed

fn unpack(packed: <(U50, U2) as BitPack>::Packed) -> (U50, U2)

impl BitPack for (U10, U40)

type Packed = U50

fn pack(self) -> <(U10, U40) as BitPack>::Packed

fn unpack(packed: <(U10, U40) as BitPack>::Packed) -> (U10, U40)

impl BitPack for (U19, U2)

type Packed = U21

fn pack(self) -> <(U19, U2) as BitPack>::Packed

fn unpack(packed: <(U19, U2) as BitPack>::Packed) -> (U19, U2)

impl BitPack for (U19, U15)

type Packed = U34

fn pack(self) -> <(U19, U15) as BitPack>::Packed

fn unpack(packed: <(U19, U15) as BitPack>::Packed) -> (U19, U15)

impl BitPack for (U33, U4)

type Packed = U37

fn pack(self) -> <(U33, U4) as BitPack>::Packed

fn unpack(packed: <(U33, U4) as BitPack>::Packed) -> (U33, U4)

impl BitPack for (U11, U40)

type Packed = U51

fn pack(self) -> <(U11, U40) as BitPack>::Packed

fn unpack(packed: <(U11, U40) as BitPack>::Packed) -> (U11, U40)

impl BitPack for (U28, U35)

type Packed = U63

fn pack(self) -> <(U28, U35) as BitPack>::Packed

fn unpack(packed: <(U28, U35) as BitPack>::Packed) -> (U28, U35)

impl BitPack for (U40, U3)

type Packed = U43

fn pack(self) -> <(U40, U3) as BitPack>::Packed

fn unpack(packed: <(U40, U3) as BitPack>::Packed) -> (U40, U3)

impl BitPack for (U48, U1)

type Packed = U49

fn pack(self) -> <(U48, U1) as BitPack>::Packed

fn unpack(packed: <(U48, U1) as BitPack>::Packed) -> (U48, U1)

impl BitPack for (u16, U4)

type Packed = U20

fn pack(self) -> <(u16, U4) as BitPack>::Packed

fn unpack(packed: <(u16, U4) as BitPack>::Packed) -> (u16, U4)

impl BitPack for (U30, U34)

type Packed = u64

fn pack(self) -> <(U30, U34) as BitPack>::Packed

fn unpack(packed: <(U30, U34) as BitPack>::Packed) -> (U30, U34)

impl BitPack for (U19, U5)

type Packed = U24

fn pack(self) -> <(U19, U5) as BitPack>::Packed

fn unpack(packed: <(U19, U5) as BitPack>::Packed) -> (U19, U5)

impl BitPack for (U18, U26)

type Packed = U44

fn pack(self) -> <(U18, U26) as BitPack>::Packed

fn unpack(packed: <(U18, U26) as BitPack>::Packed) -> (U18, U26)

impl<T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T31, <(T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T31, <(T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U25, U7)

type Packed = u32

fn pack(self) -> <(U25, U7) as BitPack>::Packed

fn unpack(packed: <(U25, U7) as BitPack>::Packed) -> (U25, U7)

impl BitPack for (U37, U18)

type Packed = U55

fn pack(self) -> <(U37, U18) as BitPack>::Packed

fn unpack(packed: <(U37, U18) as BitPack>::Packed) -> (U37, U18)

impl<T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T50, <(T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T50, <(T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U25, U35)

type Packed = U60

fn pack(self) -> <(U25, U35) as BitPack>::Packed

fn unpack(packed: <(U25, U35) as BitPack>::Packed) -> (U25, U35)

impl BitPack for (U26, U10)

type Packed = U36

fn pack(self) -> <(U26, U10) as BitPack>::Packed

fn unpack(packed: <(U26, U10) as BitPack>::Packed) -> (U26, U10)

impl BitPack for (u8, U21)

type Packed = U29

fn pack(self) -> <(u8, U21) as BitPack>::Packed

fn unpack(packed: <(u8, U21) as BitPack>::Packed) -> (u8, U21)

impl BitPack for (U49, U7)

type Packed = U56

fn pack(self) -> <(U49, U7) as BitPack>::Packed

fn unpack(packed: <(U49, U7) as BitPack>::Packed) -> (U49, U7)

impl BitPack for (U1, U27)

type Packed = U28

fn pack(self) -> <(U1, U27) as BitPack>::Packed

fn unpack(packed: <(U1, U27) as BitPack>::Packed) -> (U1, U27)

impl BitPack for (U21, U11)

type Packed = u32

fn pack(self) -> <(U21, U11) as BitPack>::Packed

fn unpack(packed: <(U21, U11) as BitPack>::Packed) -> (U21, U11)

impl BitPack for (U11, U9)

type Packed = U20

fn pack(self) -> <(U11, U9) as BitPack>::Packed

fn unpack(packed: <(U11, U9) as BitPack>::Packed) -> (U11, U9)

impl BitPack for (U3, U46)

type Packed = U49

fn pack(self) -> <(U3, U46) as BitPack>::Packed

fn unpack(packed: <(U3, U46) as BitPack>::Packed) -> (U3, U46)

impl BitPack for (U18, U9)

type Packed = U27

fn pack(self) -> <(U18, U9) as BitPack>::Packed

fn unpack(packed: <(U18, U9) as BitPack>::Packed) -> (U18, U9)

impl BitPack for (u8, U10)

type Packed = U18

fn pack(self) -> <(u8, U10) as BitPack>::Packed

fn unpack(packed: <(u8, U10) as BitPack>::Packed) -> (u8, U10)

impl<T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T34, <(T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T34, <(T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U54, U4)

type Packed = U58

fn pack(self) -> <(U54, U4) as BitPack>::Packed

fn unpack(packed: <(U54, U4) as BitPack>::Packed) -> (U54, U4)

impl BitPack for (U1, U23)

type Packed = U24

fn pack(self) -> <(U1, U23) as BitPack>::Packed

fn unpack(packed: <(U1, U23) as BitPack>::Packed) -> (U1, U23)

impl BitPack for (U34, U1)

type Packed = U35

fn pack(self) -> <(U34, U1) as BitPack>::Packed

fn unpack(packed: <(U34, U1) as BitPack>::Packed) -> (U34, U1)

impl BitPack for (U45, U19)

type Packed = u64

fn pack(self) -> <(U45, U19) as BitPack>::Packed

fn unpack(packed: <(U45, U19) as BitPack>::Packed) -> (U45, U19)

impl BitPack for (U13, U15)

type Packed = U28

fn pack(self) -> <(U13, U15) as BitPack>::Packed

fn unpack(packed: <(U13, U15) as BitPack>::Packed) -> (U13, U15)

impl BitPack for (U9, U40)

type Packed = U49

fn pack(self) -> <(U9, U40) as BitPack>::Packed

fn unpack(packed: <(U9, U40) as BitPack>::Packed) -> (U9, U40)

impl BitPack for (U5, U12)

type Packed = U17

fn pack(self) -> <(U5, U12) as BitPack>::Packed

fn unpack(packed: <(U5, U12) as BitPack>::Packed) -> (U5, U12)

impl BitPack for (U41, U20)

type Packed = U61

fn pack(self) -> <(U41, U20) as BitPack>::Packed

fn unpack(packed: <(U41, U20) as BitPack>::Packed) -> (U41, U20)

impl BitPack for (U2, U39)

type Packed = U41

fn pack(self) -> <(U2, U39) as BitPack>::Packed

fn unpack(packed: <(U2, U39) as BitPack>::Packed) -> (U2, U39)

impl BitPack for (U6, U19)

type Packed = U25

fn pack(self) -> <(U6, U19) as BitPack>::Packed

fn unpack(packed: <(U6, U19) as BitPack>::Packed) -> (U6, U19)

impl BitPack for (U10, U37)

type Packed = U47

fn pack(self) -> <(U10, U37) as BitPack>::Packed

fn unpack(packed: <(U10, U37) as BitPack>::Packed) -> (U10, U37)

impl BitPack for (U5, U39)

type Packed = U44

fn pack(self) -> <(U5, U39) as BitPack>::Packed

fn unpack(packed: <(U5, U39) as BitPack>::Packed) -> (U5, U39)

impl BitPack for (U5, U40)

type Packed = U45

fn pack(self) -> <(U5, U40) as BitPack>::Packed

fn unpack(packed: <(U5, U40) as BitPack>::Packed) -> (U5, U40)

impl BitPack for (U45, U11)

type Packed = U56

fn pack(self) -> <(U45, U11) as BitPack>::Packed

fn unpack(packed: <(U45, U11) as BitPack>::Packed) -> (U45, U11)

impl BitPack for (U4, U17)

type Packed = U21

fn pack(self) -> <(U4, U17) as BitPack>::Packed

fn unpack(packed: <(U4, U17) as BitPack>::Packed) -> (U4, U17)

impl BitPack for (U50, U14)

type Packed = u64

fn pack(self) -> <(U50, U14) as BitPack>::Packed

fn unpack(packed: <(U50, U14) as BitPack>::Packed) -> (U50, U14)

impl BitPack for (U15, U2)

type Packed = U17

fn pack(self) -> <(U15, U2) as BitPack>::Packed

fn unpack(packed: <(U15, U2) as BitPack>::Packed) -> (U15, U2)

impl BitPack for (U13, U43)

type Packed = U56

fn pack(self) -> <(U13, U43) as BitPack>::Packed

fn unpack(packed: <(U13, U43) as BitPack>::Packed) -> (U13, U43)

impl BitPack for (U17, U37)

type Packed = U54

fn pack(self) -> <(U17, U37) as BitPack>::Packed

fn unpack(packed: <(U17, U37) as BitPack>::Packed) -> (U17, U37)

impl BitPack for (U58, U4)

type Packed = U62

fn pack(self) -> <(U58, U4) as BitPack>::Packed

fn unpack(packed: <(U58, U4) as BitPack>::Packed) -> (U58, U4)

impl BitPack for (U20, U39)

type Packed = U59

fn pack(self) -> <(U20, U39) as BitPack>::Packed

fn unpack(packed: <(U20, U39) as BitPack>::Packed) -> (U20, U39)

impl BitPack for (U10, U49)

type Packed = U59

fn pack(self) -> <(U10, U49) as BitPack>::Packed

fn unpack(packed: <(U10, U49) as BitPack>::Packed) -> (U10, U49)

impl BitPack for (U3, U45)

type Packed = U48

fn pack(self) -> <(U3, U45) as BitPack>::Packed

fn unpack(packed: <(U3, U45) as BitPack>::Packed) -> (U3, U45)

impl BitPack for (U6, U39)

type Packed = U45

fn pack(self) -> <(U6, U39) as BitPack>::Packed

fn unpack(packed: <(U6, U39) as BitPack>::Packed) -> (U6, U39)

impl BitPack for (U36, U10)

type Packed = U46

fn pack(self) -> <(U36, U10) as BitPack>::Packed

fn unpack(packed: <(U36, U10) as BitPack>::Packed) -> (U36, U10)

impl BitPack for (U28, u8)

type Packed = U36

fn pack(self) -> <(U28, u8) as BitPack>::Packed

fn unpack(packed: <(U28, u8) as BitPack>::Packed) -> (U28, u8)

impl BitPack for (U28, U23)

type Packed = U51

fn pack(self) -> <(U28, U23) as BitPack>::Packed

fn unpack(packed: <(U28, U23) as BitPack>::Packed) -> (U28, U23)

impl BitPack for (U37, U11)

type Packed = U48

fn pack(self) -> <(U37, U11) as BitPack>::Packed

fn unpack(packed: <(U37, U11) as BitPack>::Packed) -> (U37, U11)

impl BitPack for (U3, U11)

type Packed = U14

fn pack(self) -> <(U3, U11) as BitPack>::Packed

fn unpack(packed: <(U3, U11) as BitPack>::Packed) -> (U3, U11)

impl BitPack for (U3, u8)

type Packed = U11

fn pack(self) -> <(U3, u8) as BitPack>::Packed

fn unpack(packed: <(U3, u8) as BitPack>::Packed) -> (U3, u8)

impl BitPack for (U13, U2)

type Packed = U15

fn pack(self) -> <(U13, U2) as BitPack>::Packed

fn unpack(packed: <(U13, U2) as BitPack>::Packed) -> (U13, U2)

impl<T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T36, <(T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T36, <(T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U24, U17)

type Packed = U41

fn pack(self) -> <(U24, U17) as BitPack>::Packed

fn unpack(packed: <(U24, U17) as BitPack>::Packed) -> (U24, U17)

impl BitPack for (U19, U13)

type Packed = u32

fn pack(self) -> <(U19, U13) as BitPack>::Packed

fn unpack(packed: <(U19, U13) as BitPack>::Packed) -> (U19, U13)

impl BitPack for (U2, u32)

type Packed = U34

fn pack(self) -> <(U2, u32) as BitPack>::Packed

fn unpack(packed: <(U2, u32) as BitPack>::Packed) -> (U2, u32)

impl BitPack for (U54, u8)

type Packed = U62

fn pack(self) -> <(U54, u8) as BitPack>::Packed

fn unpack(packed: <(U54, u8) as BitPack>::Packed) -> (U54, u8)

impl BitPack for (U3, U28)

type Packed = U31

fn pack(self) -> <(U3, U28) as BitPack>::Packed

fn unpack(packed: <(U3, U28) as BitPack>::Packed) -> (U3, U28)

impl BitPack for (U24, U2)

type Packed = U26

fn pack(self) -> <(U24, U2) as BitPack>::Packed

fn unpack(packed: <(U24, U2) as BitPack>::Packed) -> (U24, U2)

impl BitPack for (U38, U25)

type Packed = U63

fn pack(self) -> <(U38, U25) as BitPack>::Packed

fn unpack(packed: <(U38, U25) as BitPack>::Packed) -> (U38, U25)

impl BitPack for (U28, U33)

type Packed = U61

fn pack(self) -> <(U28, U33) as BitPack>::Packed

fn unpack(packed: <(U28, U33) as BitPack>::Packed) -> (U28, U33)

impl BitPack for (U14, U31)

type Packed = U45

fn pack(self) -> <(U14, U31) as BitPack>::Packed

fn unpack(packed: <(U14, U31) as BitPack>::Packed) -> (U14, U31)

impl BitPack for (U37, U17)

type Packed = U54

fn pack(self) -> <(U37, U17) as BitPack>::Packed

fn unpack(packed: <(U37, U17) as BitPack>::Packed) -> (U37, U17)

impl BitPack for (U13, U22)

type Packed = U35

fn pack(self) -> <(U13, U22) as BitPack>::Packed

fn unpack(packed: <(U13, U22) as BitPack>::Packed) -> (U13, U22)

impl BitPack for (U29, U31)

type Packed = U60

fn pack(self) -> <(U29, U31) as BitPack>::Packed

fn unpack(packed: <(U29, U31) as BitPack>::Packed) -> (U29, U31)

impl BitPack for (U52, U7)

type Packed = U59

fn pack(self) -> <(U52, U7) as BitPack>::Packed

fn unpack(packed: <(U52, U7) as BitPack>::Packed) -> (U52, U7)

impl BitPack for (U15, U46)

type Packed = U61

fn pack(self) -> <(U15, U46) as BitPack>::Packed

fn unpack(packed: <(U15, U46) as BitPack>::Packed) -> (U15, U46)

impl BitPack for (U6, U45)

type Packed = U51

fn pack(self) -> <(U6, U45) as BitPack>::Packed

fn unpack(packed: <(U6, U45) as BitPack>::Packed) -> (U6, U45)

impl BitPack for (U46, U7)

type Packed = U53

fn pack(self) -> <(U46, U7) as BitPack>::Packed

fn unpack(packed: <(U46, U7) as BitPack>::Packed) -> (U46, U7)

impl BitPack for (U10, U34)

type Packed = U44

fn pack(self) -> <(U10, U34) as BitPack>::Packed

fn unpack(packed: <(U10, U34) as BitPack>::Packed) -> (U10, U34)

impl BitPack for (U49, U3)

type Packed = U52

fn pack(self) -> <(U49, U3) as BitPack>::Packed

fn unpack(packed: <(U49, U3) as BitPack>::Packed) -> (U49, U3)

impl BitPack for (U26, U31)

type Packed = U57

fn pack(self) -> <(U26, U31) as BitPack>::Packed

fn unpack(packed: <(U26, U31) as BitPack>::Packed) -> (U26, U31)

impl BitPack for (u8, U28)

type Packed = U36

fn pack(self) -> <(u8, U28) as BitPack>::Packed

fn unpack(packed: <(u8, U28) as BitPack>::Packed) -> (u8, U28)

impl BitPack for (u16, U2)

type Packed = U18

fn pack(self) -> <(u16, U2) as BitPack>::Packed

fn unpack(packed: <(u16, U2) as BitPack>::Packed) -> (u16, U2)

impl BitPack for (U18, U22)

type Packed = U40

fn pack(self) -> <(U18, U22) as BitPack>::Packed

fn unpack(packed: <(U18, U22) as BitPack>::Packed) -> (U18, U22)

impl BitPack for (U39, U12)

type Packed = U51

fn pack(self) -> <(U39, U12) as BitPack>::Packed

fn unpack(packed: <(U39, U12) as BitPack>::Packed) -> (U39, U12)

impl BitPack for (U54, U3)

type Packed = U57

fn pack(self) -> <(U54, U3) as BitPack>::Packed

fn unpack(packed: <(U54, U3) as BitPack>::Packed) -> (U54, U3)

impl BitPack for (U43, U2)

type Packed = U45

fn pack(self) -> <(U43, U2) as BitPack>::Packed

fn unpack(packed: <(U43, U2) as BitPack>::Packed) -> (U43, U2)

impl BitPack for (U18, U36)

type Packed = U54

fn pack(self) -> <(U18, U36) as BitPack>::Packed

fn unpack(packed: <(U18, U36) as BitPack>::Packed) -> (U18, U36)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T1, <(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T1, <(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U4, U44)

type Packed = U48

fn pack(self) -> <(U4, U44) as BitPack>::Packed

fn unpack(packed: <(U4, U44) as BitPack>::Packed) -> (U4, U44)

impl BitPack for (U3, u16)

type Packed = U19

fn pack(self) -> <(U3, u16) as BitPack>::Packed

fn unpack(packed: <(U3, u16) as BitPack>::Packed) -> (U3, u16)

impl BitPack for (U2, U25)

type Packed = U27

fn pack(self) -> <(U2, U25) as BitPack>::Packed

fn unpack(packed: <(U2, U25) as BitPack>::Packed) -> (U2, U25)

impl BitPack for (U20, U33)

type Packed = U53

fn pack(self) -> <(U20, U33) as BitPack>::Packed

fn unpack(packed: <(U20, U33) as BitPack>::Packed) -> (U20, U33)

impl BitPack for (U20, U7)

type Packed = U27

fn pack(self) -> <(U20, U7) as BitPack>::Packed

fn unpack(packed: <(U20, U7) as BitPack>::Packed) -> (U20, U7)

impl BitPack for (U1, u32)

type Packed = U33

fn pack(self) -> <(U1, u32) as BitPack>::Packed

fn unpack(packed: <(U1, u32) as BitPack>::Packed) -> (U1, u32)

impl BitPack for (U42, U2)

type Packed = U44

fn pack(self) -> <(U42, U2) as BitPack>::Packed

fn unpack(packed: <(U42, U2) as BitPack>::Packed) -> (U42, U2)

impl BitPack for (U45, U13)

type Packed = U58

fn pack(self) -> <(U45, U13) as BitPack>::Packed

fn unpack(packed: <(U45, U13) as BitPack>::Packed) -> (U45, U13)

impl BitPack for (U27, U29)

type Packed = U56

fn pack(self) -> <(U27, U29) as BitPack>::Packed

fn unpack(packed: <(U27, U29) as BitPack>::Packed) -> (U27, U29)

impl BitPack for (U10, U36)

type Packed = U46

fn pack(self) -> <(U10, U36) as BitPack>::Packed

fn unpack(packed: <(U10, U36) as BitPack>::Packed) -> (U10, U36)

impl BitPack for (U7, U7)

type Packed = U14

fn pack(self) -> <(U7, U7) as BitPack>::Packed

fn unpack(packed: <(U7, U7) as BitPack>::Packed) -> (U7, U7)

impl BitPack for (U53, U3)

type Packed = U56

fn pack(self) -> <(U53, U3) as BitPack>::Packed

fn unpack(packed: <(U53, U3) as BitPack>::Packed) -> (U53, U3)

impl BitPack for (U3, U26)

type Packed = U29

fn pack(self) -> <(U3, U26) as BitPack>::Packed

fn unpack(packed: <(U3, U26) as BitPack>::Packed) -> (U3, U26)

impl BitPack for (U11, U42)

type Packed = U53

fn pack(self) -> <(U11, U42) as BitPack>::Packed

fn unpack(packed: <(U11, U42) as BitPack>::Packed) -> (U11, U42)

impl BitPack for (U40, U1)

type Packed = U41

fn pack(self) -> <(U40, U1) as BitPack>::Packed

fn unpack(packed: <(U40, U1) as BitPack>::Packed) -> (U40, U1)

impl BitPack for (U25, U34)

type Packed = U59

fn pack(self) -> <(U25, U34) as BitPack>::Packed

fn unpack(packed: <(U25, U34) as BitPack>::Packed) -> (U25, U34)

impl BitPack for (U10, U43)

type Packed = U53

fn pack(self) -> <(U10, U43) as BitPack>::Packed

fn unpack(packed: <(U10, U43) as BitPack>::Packed) -> (U10, U43)

impl BitPack for (u8, U43)

type Packed = U51

fn pack(self) -> <(u8, U43) as BitPack>::Packed

fn unpack(packed: <(u8, U43) as BitPack>::Packed) -> (u8, U43)

impl BitPack for (U13, U20)

type Packed = U33

fn pack(self) -> <(U13, U20) as BitPack>::Packed

fn unpack(packed: <(U13, U20) as BitPack>::Packed) -> (U13, U20)

impl BitPack for (U5, U13)

type Packed = U18

fn pack(self) -> <(U5, U13) as BitPack>::Packed

fn unpack(packed: <(U5, U13) as BitPack>::Packed) -> (U5, U13)

impl BitPack for (U24, U7)

type Packed = U31

fn pack(self) -> <(U24, U7) as BitPack>::Packed

fn unpack(packed: <(U24, U7) as BitPack>::Packed) -> (U24, U7)

impl<T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T57, T58, T59, T60, T61, T62, T63, T64)where
    (T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T57, <(T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T57, <(T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(self) -> <(T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U21, U2)

type Packed = U23

fn pack(self) -> <(U21, U2) as BitPack>::Packed

fn unpack(packed: <(U21, U2) as BitPack>::Packed) -> (U21, U2)

impl BitPack for (U7, U34)

type Packed = U41

fn pack(self) -> <(U7, U34) as BitPack>::Packed

fn unpack(packed: <(U7, U34) as BitPack>::Packed) -> (U7, U34)

impl BitPack for (U3, U52)

type Packed = U55

fn pack(self) -> <(U3, U52) as BitPack>::Packed

fn unpack(packed: <(U3, U52) as BitPack>::Packed) -> (U3, U52)

impl BitPack for (U17, U38)

type Packed = U55

fn pack(self) -> <(U17, U38) as BitPack>::Packed

fn unpack(packed: <(U17, U38) as BitPack>::Packed) -> (U17, U38)

impl BitPack for (U50, U3)

type Packed = U53

fn pack(self) -> <(U50, U3) as BitPack>::Packed

fn unpack(packed: <(U50, U3) as BitPack>::Packed) -> (U50, U3)

impl BitPack for (U6, U43)

type Packed = U49

fn pack(self) -> <(U6, U43) as BitPack>::Packed

fn unpack(packed: <(U6, U43) as BitPack>::Packed) -> (U6, U43)

impl BitPack for (U22, U20)

type Packed = U42

fn pack(self) -> <(U22, U20) as BitPack>::Packed

fn unpack(packed: <(U22, U20) as BitPack>::Packed) -> (U22, U20)

impl BitPack for (U34, U4)

type Packed = U38

fn pack(self) -> <(U34, U4) as BitPack>::Packed

fn unpack(packed: <(U34, U4) as BitPack>::Packed) -> (U34, U4)

impl BitPack for (U31, U10)

type Packed = U41

fn pack(self) -> <(U31, U10) as BitPack>::Packed

fn unpack(packed: <(U31, U10) as BitPack>::Packed) -> (U31, U10)

impl<T> BitPack for (T,)

type Packed = T

fn pack(self) -> <(T,) as BitPack>::Packed

fn unpack(packed: <(T,) as BitPack>::Packed) -> (T,)

impl BitPack for (U28, U19)

type Packed = U47

fn pack(self) -> <(U28, U19) as BitPack>::Packed

fn unpack(packed: <(U28, U19) as BitPack>::Packed) -> (U28, U19)

impl BitPack for (U2, U47)

type Packed = U49

fn pack(self) -> <(U2, U47) as BitPack>::Packed

fn unpack(packed: <(U2, U47) as BitPack>::Packed) -> (U2, U47)

impl BitPack for (U44, u16)

type Packed = U60

fn pack(self) -> <(U44, u16) as BitPack>::Packed

fn unpack(packed: <(U44, u16) as BitPack>::Packed) -> (U44, u16)

impl BitPack for (U38, U15)

type Packed = U53

fn pack(self) -> <(U38, U15) as BitPack>::Packed

fn unpack(packed: <(U38, U15) as BitPack>::Packed) -> (U38, U15)

impl BitPack for (U20, U24)

type Packed = U44

fn pack(self) -> <(U20, U24) as BitPack>::Packed

fn unpack(packed: <(U20, U24) as BitPack>::Packed) -> (U20, U24)

impl BitPack for (U25, U30)

type Packed = U55

fn pack(self) -> <(U25, U30) as BitPack>::Packed

fn unpack(packed: <(U25, U30) as BitPack>::Packed) -> (U25, U30)

impl BitPack for (U43, U6)

type Packed = U49

fn pack(self) -> <(U43, U6) as BitPack>::Packed

fn unpack(packed: <(U43, U6) as BitPack>::Packed) -> (U43, U6)

impl BitPack for (U1, U55)

type Packed = U56

fn pack(self) -> <(U1, U55) as BitPack>::Packed

fn unpack(packed: <(U1, U55) as BitPack>::Packed) -> (U1, U55)

impl BitPack for (U25, u16)

type Packed = U41

fn pack(self) -> <(U25, u16) as BitPack>::Packed

fn unpack(packed: <(U25, u16) as BitPack>::Packed) -> (U25, u16)

impl BitPack for (U14, U20)

type Packed = U34

fn pack(self) -> <(U14, U20) as BitPack>::Packed

fn unpack(packed: <(U14, U20) as BitPack>::Packed) -> (U14, U20)

impl BitPack for (U1, U46)

type Packed = U47

fn pack(self) -> <(U1, U46) as BitPack>::Packed

fn unpack(packed: <(U1, U46) as BitPack>::Packed) -> (U1, U46)

impl BitPack for (U34, U20)

type Packed = U54

fn pack(self) -> <(U34, U20) as BitPack>::Packed

fn unpack(packed: <(U34, U20) as BitPack>::Packed) -> (U34, U20)

impl BitPack for (U12, U25)

type Packed = U37

fn pack(self) -> <(U12, U25) as BitPack>::Packed

fn unpack(packed: <(U12, U25) as BitPack>::Packed) -> (U12, U25)

impl BitPack for (U14, U43)

type Packed = U57

fn pack(self) -> <(U14, U43) as BitPack>::Packed

fn unpack(packed: <(U14, U43) as BitPack>::Packed) -> (U14, U43)

impl BitPack for (U47, u16)

type Packed = U63

fn pack(self) -> <(U47, u16) as BitPack>::Packed

fn unpack(packed: <(U47, u16) as BitPack>::Packed) -> (U47, u16)

impl BitPack for (U1, U52)

type Packed = U53

fn pack(self) -> <(U1, U52) as BitPack>::Packed

fn unpack(packed: <(U1, U52) as BitPack>::Packed) -> (U1, U52)

impl BitPack for (U18, u8)

type Packed = U26

fn pack(self) -> <(U18, u8) as BitPack>::Packed

fn unpack(packed: <(U18, u8) as BitPack>::Packed) -> (U18, u8)

impl BitPack for (u16, U5)

type Packed = U21

fn pack(self) -> <(u16, U5) as BitPack>::Packed

fn unpack(packed: <(u16, U5) as BitPack>::Packed) -> (u16, U5)

impl BitPack for (U26, U21)

type Packed = U47

fn pack(self) -> <(U26, U21) as BitPack>::Packed

fn unpack(packed: <(U26, U21) as BitPack>::Packed) -> (U26, U21)

impl BitPack for (U21, U43)

type Packed = u64

fn pack(self) -> <(U21, U43) as BitPack>::Packed

fn unpack(packed: <(U21, U43) as BitPack>::Packed) -> (U21, U43)

impl BitPack for (U6, U58)

type Packed = u64

fn pack(self) -> <(U6, U58) as BitPack>::Packed

fn unpack(packed: <(U6, U58) as BitPack>::Packed) -> (U6, U58)

impl BitPack for (U42, U15)

type Packed = U57

fn pack(self) -> <(U42, U15) as BitPack>::Packed

fn unpack(packed: <(U42, U15) as BitPack>::Packed) -> (U42, U15)

impl BitPack for (U3, U1)

type Packed = U4

fn pack(self) -> <(U3, U1) as BitPack>::Packed

fn unpack(packed: <(U3, U1) as BitPack>::Packed) -> (U3, U1)

impl BitPack for (U22, U39)

type Packed = U61

fn pack(self) -> <(U22, U39) as BitPack>::Packed

fn unpack(packed: <(U22, U39) as BitPack>::Packed) -> (U22, U39)

impl BitPack for (U39, U21)

type Packed = U60

fn pack(self) -> <(U39, U21) as BitPack>::Packed

fn unpack(packed: <(U39, U21) as BitPack>::Packed) -> (U39, U21)

impl BitPack for (U5, U28)

type Packed = U33

fn pack(self) -> <(U5, U28) as BitPack>::Packed

fn unpack(packed: <(U5, U28) as BitPack>::Packed) -> (U5, U28)

impl BitPack for (U3, U57)

type Packed = U60

fn pack(self) -> <(U3, U57) as BitPack>::Packed

fn unpack(packed: <(U3, U57) as BitPack>::Packed) -> (U3, U57)

impl BitPack for (U3, U49)

type Packed = U52

fn pack(self) -> <(U3, U49) as BitPack>::Packed

fn unpack(packed: <(U3, U49) as BitPack>::Packed) -> (U3, U49)

impl BitPack for (U41, U1)

type Packed = U42

fn pack(self) -> <(U41, U1) as BitPack>::Packed

fn unpack(packed: <(U41, U1) as BitPack>::Packed) -> (U41, U1)

impl BitPack for (U11, U3)

type Packed = U14

fn pack(self) -> <(U11, U3) as BitPack>::Packed

fn unpack(packed: <(U11, U3) as BitPack>::Packed) -> (U11, U3)

impl BitPack for (U29, U14)

type Packed = U43

fn pack(self) -> <(U29, U14) as BitPack>::Packed

fn unpack(packed: <(U29, U14) as BitPack>::Packed) -> (U29, U14)

impl BitPack for (U17, U36)

type Packed = U53

fn pack(self) -> <(U17, U36) as BitPack>::Packed

fn unpack(packed: <(U17, U36) as BitPack>::Packed) -> (U17, U36)

impl BitPack for (U52, U9)

type Packed = U61

fn pack(self) -> <(U52, U9) as BitPack>::Packed

fn unpack(packed: <(U52, U9) as BitPack>::Packed) -> (U52, U9)

impl BitPack for (U2, U7)

type Packed = U9

fn pack(self) -> <(U2, U7) as BitPack>::Packed

fn unpack(packed: <(U2, U7) as BitPack>::Packed) -> (U2, U7)

impl BitPack for (U25, U20)

type Packed = U45

fn pack(self) -> <(U25, U20) as BitPack>::Packed

fn unpack(packed: <(U25, U20) as BitPack>::Packed) -> (U25, U20)

impl BitPack for (U45, U12)

type Packed = U57

fn pack(self) -> <(U45, U12) as BitPack>::Packed

fn unpack(packed: <(U45, U12) as BitPack>::Packed) -> (U45, U12)

impl BitPack for (U3, U31)

type Packed = U34

fn pack(self) -> <(U3, U31) as BitPack>::Packed

fn unpack(packed: <(U3, U31) as BitPack>::Packed) -> (U3, U31)

impl BitPack for (u8, U51)

type Packed = U59

fn pack(self) -> <(u8, U51) as BitPack>::Packed

fn unpack(packed: <(u8, U51) as BitPack>::Packed) -> (u8, U51)

impl BitPack for (U2, U12)

type Packed = U14

fn pack(self) -> <(U2, U12) as BitPack>::Packed

fn unpack(packed: <(U2, U12) as BitPack>::Packed) -> (U2, U12)

impl BitPack for (U36, U25)

type Packed = U61

fn pack(self) -> <(U36, U25) as BitPack>::Packed

fn unpack(packed: <(U36, U25) as BitPack>::Packed) -> (U36, U25)

impl BitPack for (u8, U7)

type Packed = U15

fn pack(self) -> <(u8, U7) as BitPack>::Packed

fn unpack(packed: <(u8, U7) as BitPack>::Packed) -> (u8, U7)

impl BitPack for (U5, U43)

type Packed = U48

fn pack(self) -> <(U5, U43) as BitPack>::Packed

fn unpack(packed: <(U5, U43) as BitPack>::Packed) -> (U5, U43)

impl BitPack for (U17, U47)

type Packed = u64

fn pack(self) -> <(U17, U47) as BitPack>::Packed

fn unpack(packed: <(U17, U47) as BitPack>::Packed) -> (U17, U47)

impl BitPack for (U20, U12)

type Packed = u32

fn pack(self) -> <(U20, U12) as BitPack>::Packed

fn unpack(packed: <(U20, U12) as BitPack>::Packed) -> (U20, U12)

impl BitPack for (u32, U25)

type Packed = U57

fn pack(self) -> <(u32, U25) as BitPack>::Packed

fn unpack(packed: <(u32, U25) as BitPack>::Packed) -> (u32, U25)

impl BitPack for (U34, U28)

type Packed = U62

fn pack(self) -> <(U34, U28) as BitPack>::Packed

fn unpack(packed: <(U34, U28) as BitPack>::Packed) -> (U34, U28)

impl BitPack for (U43, U21)

type Packed = u64

fn pack(self) -> <(U43, U21) as BitPack>::Packed

fn unpack(packed: <(U43, U21) as BitPack>::Packed) -> (U43, U21)

impl BitPack for (U25, U4)

type Packed = U29

fn pack(self) -> <(U25, U4) as BitPack>::Packed

fn unpack(packed: <(U25, U4) as BitPack>::Packed) -> (U25, U4)

impl BitPack for (U21, U13)

type Packed = U34

fn pack(self) -> <(U21, U13) as BitPack>::Packed

fn unpack(packed: <(U21, U13) as BitPack>::Packed) -> (U21, U13)

impl BitPack for (U41, U13)

type Packed = U54

fn pack(self) -> <(U41, U13) as BitPack>::Packed

fn unpack(packed: <(U41, U13) as BitPack>::Packed) -> (U41, U13)

impl BitPack for (U25, U17)

type Packed = U42

fn pack(self) -> <(U25, U17) as BitPack>::Packed

fn unpack(packed: <(U25, U17) as BitPack>::Packed) -> (U25, U17)

impl BitPack for (u16, U23)

type Packed = U39

fn pack(self) -> <(u16, U23) as BitPack>::Packed

fn unpack(packed: <(u16, U23) as BitPack>::Packed) -> (u16, U23)

impl BitPack for (U2, U15)

type Packed = U17

fn pack(self) -> <(U2, U15) as BitPack>::Packed

fn unpack(packed: <(U2, U15) as BitPack>::Packed) -> (U2, U15)

impl BitPack for (U5, U24)

type Packed = U29

fn pack(self) -> <(U5, U24) as BitPack>::Packed

fn unpack(packed: <(U5, U24) as BitPack>::Packed) -> (U5, U24)

impl BitPack for (U21, U36)

type Packed = U57

fn pack(self) -> <(U21, U36) as BitPack>::Packed

fn unpack(packed: <(U21, U36) as BitPack>::Packed) -> (U21, U36)

impl BitPack for (U23, U28)

type Packed = U51

fn pack(self) -> <(U23, U28) as BitPack>::Packed

fn unpack(packed: <(U23, U28) as BitPack>::Packed) -> (U23, U28)

impl BitPack for (U49, U15)

type Packed = u64

fn pack(self) -> <(U49, U15) as BitPack>::Packed

fn unpack(packed: <(U49, U15) as BitPack>::Packed) -> (U49, U15)

impl BitPack for (U10, U7)

type Packed = U17

fn pack(self) -> <(U10, U7) as BitPack>::Packed

fn unpack(packed: <(U10, U7) as BitPack>::Packed) -> (U10, U7)

impl BitPack for (U1, U34)

type Packed = U35

fn pack(self) -> <(U1, U34) as BitPack>::Packed

fn unpack(packed: <(U1, U34) as BitPack>::Packed) -> (U1, U34)

impl BitPack for (U1, U14)

type Packed = U15

fn pack(self) -> <(U1, U14) as BitPack>::Packed

fn unpack(packed: <(U1, U14) as BitPack>::Packed) -> (U1, U14)

impl BitPack for (U46, U9)

type Packed = U55

fn pack(self) -> <(U46, U9) as BitPack>::Packed

fn unpack(packed: <(U46, U9) as BitPack>::Packed) -> (U46, U9)

impl BitPack for (U11, U11)

type Packed = U22

fn pack(self) -> <(U11, U11) as BitPack>::Packed

fn unpack(packed: <(U11, U11) as BitPack>::Packed) -> (U11, U11)

impl BitPack for (U14, U5)

type Packed = U19

fn pack(self) -> <(U14, U5) as BitPack>::Packed

fn unpack(packed: <(U14, U5) as BitPack>::Packed) -> (U14, U5)

impl BitPack for (U17, U46)

type Packed = U63

fn pack(self) -> <(U17, U46) as BitPack>::Packed

fn unpack(packed: <(U17, U46) as BitPack>::Packed) -> (U17, U46)

impl BitPack for (U21, U24)

type Packed = U45

fn pack(self) -> <(U21, U24) as BitPack>::Packed

fn unpack(packed: <(U21, U24) as BitPack>::Packed) -> (U21, U24)

impl BitPack for (U31, u32)

type Packed = U63

fn pack(self) -> <(U31, u32) as BitPack>::Packed

fn unpack(packed: <(U31, u32) as BitPack>::Packed) -> (U31, u32)

impl BitPack for (U17, U40)

type Packed = U57

fn pack(self) -> <(U17, U40) as BitPack>::Packed

fn unpack(packed: <(U17, U40) as BitPack>::Packed) -> (U17, U40)

impl BitPack for (U35, U22)

type Packed = U57

fn pack(self) -> <(U35, U22) as BitPack>::Packed

fn unpack(packed: <(U35, U22) as BitPack>::Packed) -> (U35, U22)

impl BitPack for (U4, U48)

type Packed = U52

fn pack(self) -> <(U4, U48) as BitPack>::Packed

fn unpack(packed: <(U4, U48) as BitPack>::Packed) -> (U4, U48)

impl BitPack for (U12, U9)

type Packed = U21

fn pack(self) -> <(U12, U9) as BitPack>::Packed

fn unpack(packed: <(U12, U9) as BitPack>::Packed) -> (U12, U9)

impl BitPack for (U48, U13)

type Packed = U61

fn pack(self) -> <(U48, U13) as BitPack>::Packed

fn unpack(packed: <(U48, U13) as BitPack>::Packed) -> (U48, U13)

impl BitPack for (U24, u32)

type Packed = U56

fn pack(self) -> <(U24, u32) as BitPack>::Packed

fn unpack(packed: <(U24, u32) as BitPack>::Packed) -> (U24, u32)

impl BitPack for (U40, U2)

type Packed = U42

fn pack(self) -> <(U40, U2) as BitPack>::Packed

fn unpack(packed: <(U40, U2) as BitPack>::Packed) -> (U40, U2)

impl BitPack for (U31, U33)

type Packed = u64

fn pack(self) -> <(U31, U33) as BitPack>::Packed

fn unpack(packed: <(U31, U33) as BitPack>::Packed) -> (U31, U33)

impl BitPack for (U12, U47)

type Packed = U59

fn pack(self) -> <(U12, U47) as BitPack>::Packed

fn unpack(packed: <(U12, U47) as BitPack>::Packed) -> (U12, U47)

impl BitPack for (U20, U26)

type Packed = U46

fn pack(self) -> <(U20, U26) as BitPack>::Packed

fn unpack(packed: <(U20, U26) as BitPack>::Packed) -> (U20, U26)

impl BitPack for (U13, U34)

type Packed = U47

fn pack(self) -> <(U13, U34) as BitPack>::Packed

fn unpack(packed: <(U13, U34) as BitPack>::Packed) -> (U13, U34)

impl BitPack for (U26, U17)

type Packed = U43

fn pack(self) -> <(U26, U17) as BitPack>::Packed

fn unpack(packed: <(U26, U17) as BitPack>::Packed) -> (U26, U17)

impl BitPack for (U15, U40)

type Packed = U55

fn pack(self) -> <(U15, U40) as BitPack>::Packed

fn unpack(packed: <(U15, U40) as BitPack>::Packed) -> (U15, U40)

impl BitPack for (U3, U51)

type Packed = U54

fn pack(self) -> <(U3, U51) as BitPack>::Packed

fn unpack(packed: <(U3, U51) as BitPack>::Packed) -> (U3, U51)

impl BitPack for (U42, U22)

type Packed = u64

fn pack(self) -> <(U42, U22) as BitPack>::Packed

fn unpack(packed: <(U42, U22) as BitPack>::Packed) -> (U42, U22)

impl BitPack for (U23, U1)

type Packed = U24

fn pack(self) -> <(U23, U1) as BitPack>::Packed

fn unpack(packed: <(U23, U1) as BitPack>::Packed) -> (U23, U1)

impl BitPack for (U41, U14)

type Packed = U55

fn pack(self) -> <(U41, U14) as BitPack>::Packed

fn unpack(packed: <(U41, U14) as BitPack>::Packed) -> (U41, U14)

impl BitPack for (U45, u16)

type Packed = U61

fn pack(self) -> <(U45, u16) as BitPack>::Packed

fn unpack(packed: <(U45, u16) as BitPack>::Packed) -> (U45, u16)

impl BitPack for (U55, U2)

type Packed = U57

fn pack(self) -> <(U55, U2) as BitPack>::Packed

fn unpack(packed: <(U55, U2) as BitPack>::Packed) -> (U55, U2)

impl BitPack for (U17, U22)

type Packed = U39

fn pack(self) -> <(U17, U22) as BitPack>::Packed

fn unpack(packed: <(U17, U22) as BitPack>::Packed) -> (U17, U22)

impl BitPack for (U21, U21)

type Packed = U42

fn pack(self) -> <(U21, U21) as BitPack>::Packed

fn unpack(packed: <(U21, U21) as BitPack>::Packed) -> (U21, U21)

impl BitPack for (u16, u8)

type Packed = U24

fn pack(self) -> <(u16, u8) as BitPack>::Packed

fn unpack(packed: <(u16, u8) as BitPack>::Packed) -> (u16, u8)

impl BitPack for (U22, U25)

type Packed = U47

fn pack(self) -> <(U22, U25) as BitPack>::Packed

fn unpack(packed: <(U22, U25) as BitPack>::Packed) -> (U22, U25)

impl BitPack for (U25, U10)

type Packed = U35

fn pack(self) -> <(U25, U10) as BitPack>::Packed

fn unpack(packed: <(U25, U10) as BitPack>::Packed) -> (U25, U10)

impl BitPack for (U3, U37)

type Packed = U40

fn pack(self) -> <(U3, U37) as BitPack>::Packed

fn unpack(packed: <(U3, U37) as BitPack>::Packed) -> (U3, U37)

impl BitPack for (U5, U52)

type Packed = U57

fn pack(self) -> <(U5, U52) as BitPack>::Packed

fn unpack(packed: <(U5, U52) as BitPack>::Packed) -> (U5, U52)

impl BitPack for (u32, U2)

type Packed = U34

fn pack(self) -> <(u32, U2) as BitPack>::Packed

fn unpack(packed: <(u32, U2) as BitPack>::Packed) -> (u32, U2)

impl BitPack for (U53, u8)

type Packed = U61

fn pack(self) -> <(U53, u8) as BitPack>::Packed

fn unpack(packed: <(U53, u8) as BitPack>::Packed) -> (U53, u8)

impl BitPack for (U11, U46)

type Packed = U57

fn pack(self) -> <(U11, U46) as BitPack>::Packed

fn unpack(packed: <(U11, U46) as BitPack>::Packed) -> (U11, U46)

impl BitPack for (U12, U35)

type Packed = U47

fn pack(self) -> <(U12, U35) as BitPack>::Packed

fn unpack(packed: <(U12, U35) as BitPack>::Packed) -> (U12, U35)

impl BitPack for (U2, U55)

type Packed = U57

fn pack(self) -> <(U2, U55) as BitPack>::Packed

fn unpack(packed: <(U2, U55) as BitPack>::Packed) -> (U2, U55)

impl BitPack for (U7, U50)

type Packed = U57

fn pack(self) -> <(U7, U50) as BitPack>::Packed

fn unpack(packed: <(U7, U50) as BitPack>::Packed) -> (U7, U50)

impl BitPack for (U28, U29)

type Packed = U57

fn pack(self) -> <(U28, U29) as BitPack>::Packed

fn unpack(packed: <(U28, U29) as BitPack>::Packed) -> (U28, U29)

impl BitPack for (U36, U6)

type Packed = U42

fn pack(self) -> <(U36, U6) as BitPack>::Packed

fn unpack(packed: <(U36, U6) as BitPack>::Packed) -> (U36, U6)

impl BitPack for (U44, U18)

type Packed = U62

fn pack(self) -> <(U44, U18) as BitPack>::Packed

fn unpack(packed: <(U44, U18) as BitPack>::Packed) -> (U44, U18)

impl BitPack for (U56, U7)

type Packed = U63

fn pack(self) -> <(U56, U7) as BitPack>::Packed

fn unpack(packed: <(U56, U7) as BitPack>::Packed) -> (U56, U7)

impl BitPack for (U46, u16)

type Packed = U62

fn pack(self) -> <(U46, u16) as BitPack>::Packed

fn unpack(packed: <(U46, u16) as BitPack>::Packed) -> (U46, u16)

impl BitPack for (U4, U31)

type Packed = U35

fn pack(self) -> <(U4, U31) as BitPack>::Packed

fn unpack(packed: <(U4, U31) as BitPack>::Packed) -> (U4, U31)

impl BitPack for (U6, U47)

type Packed = U53

fn pack(self) -> <(U6, U47) as BitPack>::Packed

fn unpack(packed: <(U6, U47) as BitPack>::Packed) -> (U6, U47)

impl BitPack for (U57, U1)

type Packed = U58

fn pack(self) -> <(U57, U1) as BitPack>::Packed

fn unpack(packed: <(U57, U1) as BitPack>::Packed) -> (U57, U1)

impl BitPack for (U2, U2)

type Packed = U4

fn pack(self) -> <(U2, U2) as BitPack>::Packed

fn unpack(packed: <(U2, U2) as BitPack>::Packed) -> (U2, U2)

impl BitPack for (U33, U11)

type Packed = U44

fn pack(self) -> <(U33, U11) as BitPack>::Packed

fn unpack(packed: <(U33, U11) as BitPack>::Packed) -> (U33, U11)

impl BitPack for (U11, U31)

type Packed = U42

fn pack(self) -> <(U11, U31) as BitPack>::Packed

fn unpack(packed: <(U11, U31) as BitPack>::Packed) -> (U11, U31)

impl BitPack for (U23, U7)

type Packed = U30

fn pack(self) -> <(U23, U7) as BitPack>::Packed

fn unpack(packed: <(U23, U7) as BitPack>::Packed) -> (U23, U7)

impl BitPack for (U43, u16)

type Packed = U59

fn pack(self) -> <(U43, u16) as BitPack>::Packed

fn unpack(packed: <(U43, u16) as BitPack>::Packed) -> (U43, u16)

impl BitPack for (U11, U4)

type Packed = U15

fn pack(self) -> <(U11, U4) as BitPack>::Packed

fn unpack(packed: <(U11, U4) as BitPack>::Packed) -> (U11, U4)

impl BitPack for (U2, U21)

type Packed = U23

fn pack(self) -> <(U2, U21) as BitPack>::Packed

fn unpack(packed: <(U2, U21) as BitPack>::Packed) -> (U2, U21)

impl BitPack for (U19, U3)

type Packed = U22

fn pack(self) -> <(U19, U3) as BitPack>::Packed

fn unpack(packed: <(U19, U3) as BitPack>::Packed) -> (U19, U3)

impl BitPack for (U53, U1)

type Packed = U54

fn pack(self) -> <(U53, U1) as BitPack>::Packed

fn unpack(packed: <(U53, U1) as BitPack>::Packed) -> (U53, U1)

impl BitPack for (U30, U29)

type Packed = U59

fn pack(self) -> <(U30, U29) as BitPack>::Packed

fn unpack(packed: <(U30, U29) as BitPack>::Packed) -> (U30, U29)

impl BitPack for (U20, U42)

type Packed = U62

fn pack(self) -> <(U20, U42) as BitPack>::Packed

fn unpack(packed: <(U20, U42) as BitPack>::Packed) -> (U20, U42)

impl BitPack for (U7, U47)

type Packed = U54

fn pack(self) -> <(U7, U47) as BitPack>::Packed

fn unpack(packed: <(U7, U47) as BitPack>::Packed) -> (U7, U47)

impl BitPack for (U34, U24)

type Packed = U58

fn pack(self) -> <(U34, U24) as BitPack>::Packed

fn unpack(packed: <(U34, U24) as BitPack>::Packed) -> (U34, U24)

impl BitPack for (U37, U4)

type Packed = U41

fn pack(self) -> <(U37, U4) as BitPack>::Packed

fn unpack(packed: <(U37, U4) as BitPack>::Packed) -> (U37, U4)

impl BitPack for (U19, U20)

type Packed = U39

fn pack(self) -> <(U19, U20) as BitPack>::Packed

fn unpack(packed: <(U19, U20) as BitPack>::Packed) -> (U19, U20)

impl BitPack for (u16, U9)

type Packed = U25

fn pack(self) -> <(u16, U9) as BitPack>::Packed

fn unpack(packed: <(u16, U9) as BitPack>::Packed) -> (u16, U9)

impl BitPack for (U43, U19)

type Packed = U62

fn pack(self) -> <(U43, U19) as BitPack>::Packed

fn unpack(packed: <(U43, U19) as BitPack>::Packed) -> (U43, U19)

impl BitPack for (U35, U17)

type Packed = U52

fn pack(self) -> <(U35, U17) as BitPack>::Packed

fn unpack(packed: <(U35, U17) as BitPack>::Packed) -> (U35, U17)

impl BitPack for (U18, U38)

type Packed = U56

fn pack(self) -> <(U18, U38) as BitPack>::Packed

fn unpack(packed: <(U18, U38) as BitPack>::Packed) -> (U18, U38)

impl BitPack for (U14, U23)

type Packed = U37

fn pack(self) -> <(U14, U23) as BitPack>::Packed

fn unpack(packed: <(U14, U23) as BitPack>::Packed) -> (U14, U23)

impl BitPack for (U1, U47)

type Packed = U48

fn pack(self) -> <(U1, U47) as BitPack>::Packed

fn unpack(packed: <(U1, U47) as BitPack>::Packed) -> (U1, U47)

impl BitPack for (U30, U9)

type Packed = U39

fn pack(self) -> <(U30, U9) as BitPack>::Packed

fn unpack(packed: <(U30, U9) as BitPack>::Packed) -> (U30, U9)

impl BitPack for (U27, U1)

type Packed = U28

fn pack(self) -> <(U27, U1) as BitPack>::Packed

fn unpack(packed: <(U27, U1) as BitPack>::Packed) -> (U27, U1)

impl BitPack for (U40, U24)

type Packed = u64

fn pack(self) -> <(U40, U24) as BitPack>::Packed

fn unpack(packed: <(U40, U24) as BitPack>::Packed) -> (U40, U24)

impl BitPack for (U4, U34)

type Packed = U38

fn pack(self) -> <(U4, U34) as BitPack>::Packed

fn unpack(packed: <(U4, U34) as BitPack>::Packed) -> (U4, U34)

impl BitPack for (U53, U6)

type Packed = U59

fn pack(self) -> <(U53, U6) as BitPack>::Packed

fn unpack(packed: <(U53, U6) as BitPack>::Packed) -> (U53, U6)

impl BitPack for (U17, U21)

type Packed = U38

fn pack(self) -> <(U17, U21) as BitPack>::Packed

fn unpack(packed: <(U17, U21) as BitPack>::Packed) -> (U17, U21)

impl BitPack for (u32, U30)

type Packed = U62

fn pack(self) -> <(u32, U30) as BitPack>::Packed

fn unpack(packed: <(u32, U30) as BitPack>::Packed) -> (u32, U30)

impl BitPack for (U23, U15)

type Packed = U38

fn pack(self) -> <(U23, U15) as BitPack>::Packed

fn unpack(packed: <(U23, U15) as BitPack>::Packed) -> (U23, U15)

impl<T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T38, <(T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T38, <(T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U31, U20)

type Packed = U51

fn pack(self) -> <(U31, U20) as BitPack>::Packed

fn unpack(packed: <(U31, U20) as BitPack>::Packed) -> (U31, U20)

impl BitPack for (U17, U20)

type Packed = U37

fn pack(self) -> <(U17, U20) as BitPack>::Packed

fn unpack(packed: <(U17, U20) as BitPack>::Packed) -> (U17, U20)

impl BitPack for (U33, U2)

type Packed = U35

fn pack(self) -> <(U33, U2) as BitPack>::Packed

fn unpack(packed: <(U33, U2) as BitPack>::Packed) -> (U33, U2)

impl BitPack for (U4, U57)

type Packed = U61

fn pack(self) -> <(U4, U57) as BitPack>::Packed

fn unpack(packed: <(U4, U57) as BitPack>::Packed) -> (U4, U57)

impl BitPack for (U20, U30)

type Packed = U50

fn pack(self) -> <(U20, U30) as BitPack>::Packed

fn unpack(packed: <(U20, U30) as BitPack>::Packed) -> (U20, U30)

impl BitPack for (U38, U14)

type Packed = U52

fn pack(self) -> <(U38, U14) as BitPack>::Packed

fn unpack(packed: <(U38, U14) as BitPack>::Packed) -> (U38, U14)

impl BitPack for (U57, U7)

type Packed = u64

fn pack(self) -> <(U57, U7) as BitPack>::Packed

fn unpack(packed: <(U57, U7) as BitPack>::Packed) -> (U57, U7)

impl BitPack for (U2, U52)

type Packed = U54

fn pack(self) -> <(U2, U52) as BitPack>::Packed

fn unpack(packed: <(U2, U52) as BitPack>::Packed) -> (U2, U52)

impl BitPack for (U47, U13)

type Packed = U60

fn pack(self) -> <(U47, U13) as BitPack>::Packed

fn unpack(packed: <(U47, U13) as BitPack>::Packed) -> (U47, U13)

impl BitPack for (U28, U34)

type Packed = U62

fn pack(self) -> <(U28, U34) as BitPack>::Packed

fn unpack(packed: <(U28, U34) as BitPack>::Packed) -> (U28, U34)

impl BitPack for (U29, U4)

type Packed = U33

fn pack(self) -> <(U29, U4) as BitPack>::Packed

fn unpack(packed: <(U29, U4) as BitPack>::Packed) -> (U29, U4)

impl BitPack for (U21, U25)

type Packed = U46

fn pack(self) -> <(U21, U25) as BitPack>::Packed

fn unpack(packed: <(U21, U25) as BitPack>::Packed) -> (U21, U25)

impl BitPack for (u16, U10)

type Packed = U26

fn pack(self) -> <(u16, U10) as BitPack>::Packed

fn unpack(packed: <(u16, U10) as BitPack>::Packed) -> (u16, U10)

impl BitPack for (u16, u16)

type Packed = u32

fn pack(self) -> <(u16, u16) as BitPack>::Packed

fn unpack(packed: <(u16, u16) as BitPack>::Packed) -> (u16, u16)

impl BitPack for (U43, U10)

type Packed = U53

fn pack(self) -> <(U43, U10) as BitPack>::Packed

fn unpack(packed: <(U43, U10) as BitPack>::Packed) -> (U43, U10)

impl BitPack for (U27, U12)

type Packed = U39

fn pack(self) -> <(U27, U12) as BitPack>::Packed

fn unpack(packed: <(U27, U12) as BitPack>::Packed) -> (U27, U12)

impl BitPack for (U12, U6)

type Packed = U18

fn pack(self) -> <(U12, U6) as BitPack>::Packed

fn unpack(packed: <(U12, U6) as BitPack>::Packed) -> (U12, U6)

impl BitPack for (U5, U3)

type Packed = u8

fn pack(self) -> <(U5, U3) as BitPack>::Packed

fn unpack(packed: <(U5, U3) as BitPack>::Packed) -> (U5, U3)

impl BitPack for (U21, U7)

type Packed = U28

fn pack(self) -> <(U21, U7) as BitPack>::Packed

fn unpack(packed: <(U21, U7) as BitPack>::Packed) -> (U21, U7)

impl BitPack for (U37, U6)

type Packed = U43

fn pack(self) -> <(U37, U6) as BitPack>::Packed

fn unpack(packed: <(U37, U6) as BitPack>::Packed) -> (U37, U6)

impl BitPack for (U6, U36)

type Packed = U42

fn pack(self) -> <(U6, U36) as BitPack>::Packed

fn unpack(packed: <(U6, U36) as BitPack>::Packed) -> (U6, U36)

impl BitPack for (U3, U53)

type Packed = U56

fn pack(self) -> <(U3, U53) as BitPack>::Packed

fn unpack(packed: <(U3, U53) as BitPack>::Packed) -> (U3, U53)

impl BitPack for (U35, U24)

type Packed = U59

fn pack(self) -> <(U35, U24) as BitPack>::Packed

fn unpack(packed: <(U35, U24) as BitPack>::Packed) -> (U35, U24)

impl BitPack for (U50, U10)

type Packed = U60

fn pack(self) -> <(U50, U10) as BitPack>::Packed

fn unpack(packed: <(U50, U10) as BitPack>::Packed) -> (U50, U10)

impl BitPack for (U52, u8)

type Packed = U60

fn pack(self) -> <(U52, u8) as BitPack>::Packed

fn unpack(packed: <(U52, u8) as BitPack>::Packed) -> (U52, u8)

impl BitPack for (U30, U5)

type Packed = U35

fn pack(self) -> <(U30, U5) as BitPack>::Packed

fn unpack(packed: <(U30, U5) as BitPack>::Packed) -> (U30, U5)

impl BitPack for (U42, U17)

type Packed = U59

fn pack(self) -> <(U42, U17) as BitPack>::Packed

fn unpack(packed: <(U42, U17) as BitPack>::Packed) -> (U42, U17)

impl BitPack for (U2, U23)

type Packed = U25

fn pack(self) -> <(U2, U23) as BitPack>::Packed

fn unpack(packed: <(U2, U23) as BitPack>::Packed) -> (U2, U23)

impl BitPack for (U10, U18)

type Packed = U28

fn pack(self) -> <(U10, U18) as BitPack>::Packed

fn unpack(packed: <(U10, U18) as BitPack>::Packed) -> (U10, U18)

impl BitPack for (U6, U6)

type Packed = U12

fn pack(self) -> <(U6, U6) as BitPack>::Packed

fn unpack(packed: <(U6, U6) as BitPack>::Packed) -> (U6, U6)

impl BitPack for (U27, u16)

type Packed = U43

fn pack(self) -> <(U27, u16) as BitPack>::Packed

fn unpack(packed: <(U27, u16) as BitPack>::Packed) -> (U27, u16)

impl BitPack for (U28, U11)

type Packed = U39

fn pack(self) -> <(U28, U11) as BitPack>::Packed

fn unpack(packed: <(U28, U11) as BitPack>::Packed) -> (U28, U11)

impl BitPack for (U18, U37)

type Packed = U55

fn pack(self) -> <(U18, U37) as BitPack>::Packed

fn unpack(packed: <(U18, U37) as BitPack>::Packed) -> (U18, U37)

impl BitPack for (U9, U18)

type Packed = U27

fn pack(self) -> <(U9, U18) as BitPack>::Packed

fn unpack(packed: <(U9, U18) as BitPack>::Packed) -> (U9, U18)

impl BitPack for (U3, U34)

type Packed = U37

fn pack(self) -> <(U3, U34) as BitPack>::Packed

fn unpack(packed: <(U3, U34) as BitPack>::Packed) -> (U3, U34)

impl BitPack for (U23, U9)

type Packed = u32

fn pack(self) -> <(U23, U9) as BitPack>::Packed

fn unpack(packed: <(U23, U9) as BitPack>::Packed) -> (U23, U9)

impl BitPack for (U1, U18)

type Packed = U19

fn pack(self) -> <(U1, U18) as BitPack>::Packed

fn unpack(packed: <(U1, U18) as BitPack>::Packed) -> (U1, U18)

impl BitPack for (U12, U26)

type Packed = U38

fn pack(self) -> <(U12, U26) as BitPack>::Packed

fn unpack(packed: <(U12, U26) as BitPack>::Packed) -> (U12, U26)

impl BitPack for (U15, U30)

type Packed = U45

fn pack(self) -> <(U15, U30) as BitPack>::Packed

fn unpack(packed: <(U15, U30) as BitPack>::Packed) -> (U15, U30)

impl BitPack for (U59, U3)

type Packed = U62

fn pack(self) -> <(U59, U3) as BitPack>::Packed

fn unpack(packed: <(U59, U3) as BitPack>::Packed) -> (U59, U3)

impl BitPack for (U35, U18)

type Packed = U53

fn pack(self) -> <(U35, U18) as BitPack>::Packed

fn unpack(packed: <(U35, U18) as BitPack>::Packed) -> (U35, U18)

impl BitPack for (U7, U57)

type Packed = u64

fn pack(self) -> <(U7, U57) as BitPack>::Packed

fn unpack(packed: <(U7, U57) as BitPack>::Packed) -> (U7, U57)

impl BitPack for (U9, U37)

type Packed = U46

fn pack(self) -> <(U9, U37) as BitPack>::Packed

fn unpack(packed: <(U9, U37) as BitPack>::Packed) -> (U9, U37)

impl BitPack for (U5, U41)

type Packed = U46

fn pack(self) -> <(U5, U41) as BitPack>::Packed

fn unpack(packed: <(U5, U41) as BitPack>::Packed) -> (U5, U41)

impl BitPack for (U28, U18)

type Packed = U46

fn pack(self) -> <(U28, U18) as BitPack>::Packed

fn unpack(packed: <(U28, U18) as BitPack>::Packed) -> (U28, U18)

impl BitPack for (U1, U26)

type Packed = U27

fn pack(self) -> <(U1, U26) as BitPack>::Packed

fn unpack(packed: <(U1, U26) as BitPack>::Packed) -> (U1, U26)

impl BitPack for (U28, U20)

type Packed = U48

fn pack(self) -> <(U28, U20) as BitPack>::Packed

fn unpack(packed: <(U28, U20) as BitPack>::Packed) -> (U28, U20)

impl BitPack for (U45, U2)

type Packed = U47

fn pack(self) -> <(U45, U2) as BitPack>::Packed

fn unpack(packed: <(U45, U2) as BitPack>::Packed) -> (U45, U2)

impl BitPack for (U40, U12)

type Packed = U52

fn pack(self) -> <(U40, U12) as BitPack>::Packed

fn unpack(packed: <(U40, U12) as BitPack>::Packed) -> (U40, U12)

impl BitPack for (U18, U1)

type Packed = U19

fn pack(self) -> <(U18, U1) as BitPack>::Packed

fn unpack(packed: <(U18, U1) as BitPack>::Packed) -> (U18, U1)

impl BitPack for (U13, U21)

type Packed = U34

fn pack(self) -> <(U13, U21) as BitPack>::Packed

fn unpack(packed: <(U13, U21) as BitPack>::Packed) -> (U13, U21)

impl BitPack for (U5, U42)

type Packed = U47

fn pack(self) -> <(U5, U42) as BitPack>::Packed

fn unpack(packed: <(U5, U42) as BitPack>::Packed) -> (U5, U42)

impl BitPack for (U2, U54)

type Packed = U56

fn pack(self) -> <(U2, U54) as BitPack>::Packed

fn unpack(packed: <(U2, U54) as BitPack>::Packed) -> (U2, U54)

impl BitPack for (U22, U5)

type Packed = U27

fn pack(self) -> <(U22, U5) as BitPack>::Packed

fn unpack(packed: <(U22, U5) as BitPack>::Packed) -> (U22, U5)

impl BitPack for (U17, U5)

type Packed = U22

fn pack(self) -> <(U17, U5) as BitPack>::Packed

fn unpack(packed: <(U17, U5) as BitPack>::Packed) -> (U17, U5)

impl BitPack for (U12, U2)

type Packed = U14

fn pack(self) -> <(U12, U2) as BitPack>::Packed

fn unpack(packed: <(U12, U2) as BitPack>::Packed) -> (U12, U2)

impl BitPack for (U14, U27)

type Packed = U41

fn pack(self) -> <(U14, U27) as BitPack>::Packed

fn unpack(packed: <(U14, U27) as BitPack>::Packed) -> (U14, U27)

impl<T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T48, <(T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T48, <(T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U6, u32)

type Packed = U38

fn pack(self) -> <(U6, u32) as BitPack>::Packed

fn unpack(packed: <(U6, u32) as BitPack>::Packed) -> (U6, u32)

impl BitPack for (U33, U6)

type Packed = U39

fn pack(self) -> <(U33, U6) as BitPack>::Packed

fn unpack(packed: <(U33, U6) as BitPack>::Packed) -> (U33, U6)

impl BitPack for (U2, U61)

type Packed = U63

fn pack(self) -> <(U2, U61) as BitPack>::Packed

fn unpack(packed: <(U2, U61) as BitPack>::Packed) -> (U2, U61)

impl BitPack for (U28, U25)

type Packed = U53

fn pack(self) -> <(U28, U25) as BitPack>::Packed

fn unpack(packed: <(U28, U25) as BitPack>::Packed) -> (U28, U25)

impl BitPack for (U6, U13)

type Packed = U19

fn pack(self) -> <(U6, U13) as BitPack>::Packed

fn unpack(packed: <(U6, U13) as BitPack>::Packed) -> (U6, U13)

impl BitPack for (u16, U44)

type Packed = U60

fn pack(self) -> <(u16, U44) as BitPack>::Packed

fn unpack(packed: <(u16, U44) as BitPack>::Packed) -> (u16, U44)

impl BitPack for (u8, U27)

type Packed = U35

fn pack(self) -> <(u8, U27) as BitPack>::Packed

fn unpack(packed: <(u8, U27) as BitPack>::Packed) -> (u8, U27)

impl BitPack for (U7, U46)

type Packed = U53

fn pack(self) -> <(U7, U46) as BitPack>::Packed

fn unpack(packed: <(U7, U46) as BitPack>::Packed) -> (U7, U46)

impl BitPack for (u8, U17)

type Packed = U25

fn pack(self) -> <(u8, U17) as BitPack>::Packed

fn unpack(packed: <(u8, U17) as BitPack>::Packed) -> (u8, U17)

impl BitPack for (U12, U52)

type Packed = u64

fn pack(self) -> <(U12, U52) as BitPack>::Packed

fn unpack(packed: <(U12, U52) as BitPack>::Packed) -> (U12, U52)

impl BitPack for (U10, U3)

type Packed = U13

fn pack(self) -> <(U10, U3) as BitPack>::Packed

fn unpack(packed: <(U10, U3) as BitPack>::Packed) -> (U10, U3)

impl BitPack for (U50, U11)

type Packed = U61

fn pack(self) -> <(U50, U11) as BitPack>::Packed

fn unpack(packed: <(U50, U11) as BitPack>::Packed) -> (U50, U11)

impl BitPack for (U13, U40)

type Packed = U53

fn pack(self) -> <(U13, U40) as BitPack>::Packed

fn unpack(packed: <(U13, U40) as BitPack>::Packed) -> (U13, U40)

impl BitPack for (u32, U17)

type Packed = U49

fn pack(self) -> <(u32, U17) as BitPack>::Packed

fn unpack(packed: <(u32, U17) as BitPack>::Packed) -> (u32, U17)

impl BitPack for (U17, u8)

type Packed = U25

fn pack(self) -> <(U17, u8) as BitPack>::Packed

fn unpack(packed: <(U17, u8) as BitPack>::Packed) -> (U17, u8)

impl BitPack for (U35, U9)

type Packed = U44

fn pack(self) -> <(U35, U9) as BitPack>::Packed

fn unpack(packed: <(U35, U9) as BitPack>::Packed) -> (U35, U9)

impl BitPack for (U15, U22)

type Packed = U37

fn pack(self) -> <(U15, U22) as BitPack>::Packed

fn unpack(packed: <(U15, U22) as BitPack>::Packed) -> (U15, U22)

impl BitPack for (U20, U44)

type Packed = u64

fn pack(self) -> <(U20, U44) as BitPack>::Packed

fn unpack(packed: <(U20, U44) as BitPack>::Packed) -> (U20, U44)

impl BitPack for (U4, u8)

type Packed = U12

fn pack(self) -> <(U4, u8) as BitPack>::Packed

fn unpack(packed: <(U4, u8) as BitPack>::Packed) -> (U4, u8)

impl BitPack for (U12, U29)

type Packed = U41

fn pack(self) -> <(U12, U29) as BitPack>::Packed

fn unpack(packed: <(U12, U29) as BitPack>::Packed) -> (U12, U29)

impl BitPack for (U1, U42)

type Packed = U43

fn pack(self) -> <(U1, U42) as BitPack>::Packed

fn unpack(packed: <(U1, U42) as BitPack>::Packed) -> (U1, U42)

impl BitPack for (U12, U17)

type Packed = U29

fn pack(self) -> <(U12, U17) as BitPack>::Packed

fn unpack(packed: <(U12, U17) as BitPack>::Packed) -> (U12, U17)

impl BitPack for (U19, U33)

type Packed = U52

fn pack(self) -> <(U19, U33) as BitPack>::Packed

fn unpack(packed: <(U19, U33) as BitPack>::Packed) -> (U19, U33)

impl BitPack for (U22, U27)

type Packed = U49

fn pack(self) -> <(U22, U27) as BitPack>::Packed

fn unpack(packed: <(U22, U27) as BitPack>::Packed) -> (U22, U27)

impl BitPack for (U5, U51)

type Packed = U56

fn pack(self) -> <(U5, U51) as BitPack>::Packed

fn unpack(packed: <(U5, U51) as BitPack>::Packed) -> (U5, U51)

impl BitPack for (U15, U5)

type Packed = U20

fn pack(self) -> <(U15, U5) as BitPack>::Packed

fn unpack(packed: <(U15, U5) as BitPack>::Packed) -> (U15, U5)

impl BitPack for (U7, U53)

type Packed = U60

fn pack(self) -> <(U7, U53) as BitPack>::Packed

fn unpack(packed: <(U7, U53) as BitPack>::Packed) -> (U7, U53)

impl BitPack for (U35, U5)

type Packed = U40

fn pack(self) -> <(U35, U5) as BitPack>::Packed

fn unpack(packed: <(U35, U5) as BitPack>::Packed) -> (U35, U5)

impl BitPack for (U44, U13)

type Packed = U57

fn pack(self) -> <(U44, U13) as BitPack>::Packed

fn unpack(packed: <(U44, U13) as BitPack>::Packed) -> (U44, U13)

impl BitPack for (U13, U19)

type Packed = u32

fn pack(self) -> <(U13, U19) as BitPack>::Packed

fn unpack(packed: <(U13, U19) as BitPack>::Packed) -> (U13, U19)

impl<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T4, <(T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T4, <(T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U17, U30)

type Packed = U47

fn pack(self) -> <(U17, U30) as BitPack>::Packed

fn unpack(packed: <(U17, U30) as BitPack>::Packed) -> (U17, U30)

impl BitPack for (u8, U6)

type Packed = U14

fn pack(self) -> <(u8, U6) as BitPack>::Packed

fn unpack(packed: <(u8, U6) as BitPack>::Packed) -> (u8, U6)

impl BitPack for (U5, U46)

type Packed = U51

fn pack(self) -> <(U5, U46) as BitPack>::Packed

fn unpack(packed: <(U5, U46) as BitPack>::Packed) -> (U5, U46)

impl BitPack for (U31, U27)

type Packed = U58

fn pack(self) -> <(U31, U27) as BitPack>::Packed

fn unpack(packed: <(U31, U27) as BitPack>::Packed) -> (U31, U27)

impl BitPack for (U7, U17)

type Packed = U24

fn pack(self) -> <(U7, U17) as BitPack>::Packed

fn unpack(packed: <(U7, U17) as BitPack>::Packed) -> (U7, U17)

impl BitPack for (U37, U19)

type Packed = U56

fn pack(self) -> <(U37, U19) as BitPack>::Packed

fn unpack(packed: <(U37, U19) as BitPack>::Packed) -> (U37, U19)

impl BitPack for (U9, U50)

type Packed = U59

fn pack(self) -> <(U9, U50) as BitPack>::Packed

fn unpack(packed: <(U9, U50) as BitPack>::Packed) -> (U9, U50)

impl BitPack for (U20, U21)

type Packed = U41

fn pack(self) -> <(U20, U21) as BitPack>::Packed

fn unpack(packed: <(U20, U21) as BitPack>::Packed) -> (U20, U21)

impl BitPack for (U29, U21)

type Packed = U50

fn pack(self) -> <(U29, U21) as BitPack>::Packed

fn unpack(packed: <(U29, U21) as BitPack>::Packed) -> (U29, U21)

impl<T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T32, <(T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T32, <(T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U44, U7)

type Packed = U51

fn pack(self) -> <(U44, U7) as BitPack>::Packed

fn unpack(packed: <(U44, U7) as BitPack>::Packed) -> (U44, U7)

impl BitPack for (U28, U26)

type Packed = U54

fn pack(self) -> <(U28, U26) as BitPack>::Packed

fn unpack(packed: <(U28, U26) as BitPack>::Packed) -> (U28, U26)

impl BitPack for (U2, U4)

type Packed = U6

fn pack(self) -> <(U2, U4) as BitPack>::Packed

fn unpack(packed: <(U2, U4) as BitPack>::Packed) -> (U2, U4)

impl BitPack for (U15, U20)

type Packed = U35

fn pack(self) -> <(U15, U20) as BitPack>::Packed

fn unpack(packed: <(U15, U20) as BitPack>::Packed) -> (U15, U20)

impl BitPack for (U31, U12)

type Packed = U43

fn pack(self) -> <(U31, U12) as BitPack>::Packed

fn unpack(packed: <(U31, U12) as BitPack>::Packed) -> (U31, U12)

impl BitPack for (U10, U17)

type Packed = U27

fn pack(self) -> <(U10, U17) as BitPack>::Packed

fn unpack(packed: <(U10, U17) as BitPack>::Packed) -> (U10, U17)

impl BitPack for (U34, U22)

type Packed = U56

fn pack(self) -> <(U34, U22) as BitPack>::Packed

fn unpack(packed: <(U34, U22) as BitPack>::Packed) -> (U34, U22)

impl BitPack for (U49, U5)

type Packed = U54

fn pack(self) -> <(U49, U5) as BitPack>::Packed

fn unpack(packed: <(U49, U5) as BitPack>::Packed) -> (U49, U5)

impl BitPack for (U3, U41)

type Packed = U44

fn pack(self) -> <(U3, U41) as BitPack>::Packed

fn unpack(packed: <(U3, U41) as BitPack>::Packed) -> (U3, U41)

impl BitPack for (U28, U4)

type Packed = u32

fn pack(self) -> <(U28, U4) as BitPack>::Packed

fn unpack(packed: <(U28, U4) as BitPack>::Packed) -> (U28, U4)

impl BitPack for (U18, U2)

type Packed = U20

fn pack(self) -> <(U18, U2) as BitPack>::Packed

fn unpack(packed: <(U18, U2) as BitPack>::Packed) -> (U18, U2)

impl BitPack for (U13, U25)

type Packed = U38

fn pack(self) -> <(U13, U25) as BitPack>::Packed

fn unpack(packed: <(U13, U25) as BitPack>::Packed) -> (U13, U25)

impl BitPack for (U7, U1)

type Packed = u8

fn pack(self) -> <(U7, U1) as BitPack>::Packed

fn unpack(packed: <(U7, U1) as BitPack>::Packed) -> (U7, U1)

impl BitPack for (U21, U5)

type Packed = U26

fn pack(self) -> <(U21, U5) as BitPack>::Packed

fn unpack(packed: <(U21, U5) as BitPack>::Packed) -> (U21, U5)

impl BitPack for (U6, U44)

type Packed = U50

fn pack(self) -> <(U6, U44) as BitPack>::Packed

fn unpack(packed: <(U6, U44) as BitPack>::Packed) -> (U6, U44)

impl BitPack for (U22, U23)

type Packed = U45

fn pack(self) -> <(U22, U23) as BitPack>::Packed

fn unpack(packed: <(U22, U23) as BitPack>::Packed) -> (U22, U23)

impl BitPack for (U55, U5)

type Packed = U60

fn pack(self) -> <(U55, U5) as BitPack>::Packed

fn unpack(packed: <(U55, U5) as BitPack>::Packed) -> (U55, U5)

impl BitPack for (U4, U51)

type Packed = U55

fn pack(self) -> <(U4, U51) as BitPack>::Packed

fn unpack(packed: <(U4, U51) as BitPack>::Packed) -> (U4, U51)

impl BitPack for (U4, U21)

type Packed = U25

fn pack(self) -> <(U4, U21) as BitPack>::Packed

fn unpack(packed: <(U4, U21) as BitPack>::Packed) -> (U4, U21)

impl BitPack for (U35, U29)

type Packed = u64

fn pack(self) -> <(U35, U29) as BitPack>::Packed

fn unpack(packed: <(U35, U29) as BitPack>::Packed) -> (U35, U29)

impl BitPack for (U30, u8)

type Packed = U38

fn pack(self) -> <(U30, u8) as BitPack>::Packed

fn unpack(packed: <(U30, u8) as BitPack>::Packed) -> (U30, u8)

impl BitPack for (U52, U12)

type Packed = u64

fn pack(self) -> <(U52, U12) as BitPack>::Packed

fn unpack(packed: <(U52, U12) as BitPack>::Packed) -> (U52, U12)

impl BitPack for (U40, u16)

type Packed = U56

fn pack(self) -> <(U40, u16) as BitPack>::Packed

fn unpack(packed: <(U40, u16) as BitPack>::Packed) -> (U40, u16)

impl BitPack for (U24, U34)

type Packed = U58

fn pack(self) -> <(U24, U34) as BitPack>::Packed

fn unpack(packed: <(U24, U34) as BitPack>::Packed) -> (U24, U34)

impl BitPack for (U9, U29)

type Packed = U38

fn pack(self) -> <(U9, U29) as BitPack>::Packed

fn unpack(packed: <(U9, U29) as BitPack>::Packed) -> (U9, U29)

impl<T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T11, <(T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T11, <(T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U45, U10)

type Packed = U55

fn pack(self) -> <(U45, U10) as BitPack>::Packed

fn unpack(packed: <(U45, U10) as BitPack>::Packed) -> (U45, U10)

impl BitPack for (U22, U38)

type Packed = U60

fn pack(self) -> <(U22, U38) as BitPack>::Packed

fn unpack(packed: <(U22, U38) as BitPack>::Packed) -> (U22, U38)

impl BitPack for (U52, U2)

type Packed = U54

fn pack(self) -> <(U52, U2) as BitPack>::Packed

fn unpack(packed: <(U52, U2) as BitPack>::Packed) -> (U52, U2)

impl BitPack for (U50, U4)

type Packed = U54

fn pack(self) -> <(U50, U4) as BitPack>::Packed

fn unpack(packed: <(U50, U4) as BitPack>::Packed) -> (U50, U4)

impl BitPack for (U38, U12)

type Packed = U50

fn pack(self) -> <(U38, U12) as BitPack>::Packed

fn unpack(packed: <(U38, U12) as BitPack>::Packed) -> (U38, U12)

impl BitPack for (U6, U33)

type Packed = U39

fn pack(self) -> <(U6, U33) as BitPack>::Packed

fn unpack(packed: <(U6, U33) as BitPack>::Packed) -> (U6, U33)

impl BitPack for (U21, U39)

type Packed = U60

fn pack(self) -> <(U21, U39) as BitPack>::Packed

fn unpack(packed: <(U21, U39) as BitPack>::Packed) -> (U21, U39)

impl BitPack for (U25, U28)

type Packed = U53

fn pack(self) -> <(U25, U28) as BitPack>::Packed

fn unpack(packed: <(U25, U28) as BitPack>::Packed) -> (U25, U28)

impl BitPack for (U15, U48)

type Packed = U63

fn pack(self) -> <(U15, U48) as BitPack>::Packed

fn unpack(packed: <(U15, U48) as BitPack>::Packed) -> (U15, U48)

impl BitPack for (U14, U34)

type Packed = U48

fn pack(self) -> <(U14, U34) as BitPack>::Packed

fn unpack(packed: <(U14, U34) as BitPack>::Packed) -> (U14, U34)

impl BitPack for (U20, U19)

type Packed = U39

fn pack(self) -> <(U20, U19) as BitPack>::Packed

fn unpack(packed: <(U20, U19) as BitPack>::Packed) -> (U20, U19)

impl BitPack for (U25, U29)

type Packed = U54

fn pack(self) -> <(U25, U29) as BitPack>::Packed

fn unpack(packed: <(U25, U29) as BitPack>::Packed) -> (U25, U29)

impl BitPack for (U22, U35)

type Packed = U57

fn pack(self) -> <(U22, U35) as BitPack>::Packed

fn unpack(packed: <(U22, U35) as BitPack>::Packed) -> (U22, U35)

impl BitPack for (U40, U5)

type Packed = U45

fn pack(self) -> <(U40, U5) as BitPack>::Packed

fn unpack(packed: <(U40, U5) as BitPack>::Packed) -> (U40, U5)

impl BitPack for (U13, U6)

type Packed = U19

fn pack(self) -> <(U13, U6) as BitPack>::Packed

fn unpack(packed: <(U13, U6) as BitPack>::Packed) -> (U13, U6)

impl BitPack for (U36, U3)

type Packed = U39

fn pack(self) -> <(U36, U3) as BitPack>::Packed

fn unpack(packed: <(U36, U3) as BitPack>::Packed) -> (U36, U3)

impl BitPack for (U39, U23)

type Packed = U62

fn pack(self) -> <(U39, U23) as BitPack>::Packed

fn unpack(packed: <(U39, U23) as BitPack>::Packed) -> (U39, U23)

impl BitPack for (U41, U7)

type Packed = U48

fn pack(self) -> <(U41, U7) as BitPack>::Packed

fn unpack(packed: <(U41, U7) as BitPack>::Packed) -> (U41, U7)

impl BitPack for (U5, U55)

type Packed = U60

fn pack(self) -> <(U5, U55) as BitPack>::Packed

fn unpack(packed: <(U5, U55) as BitPack>::Packed) -> (U5, U55)

impl BitPack for (U11, U28)

type Packed = U39

fn pack(self) -> <(U11, U28) as BitPack>::Packed

fn unpack(packed: <(U11, U28) as BitPack>::Packed) -> (U11, U28)

impl BitPack for (U14, U14)

type Packed = U28

fn pack(self) -> <(U14, U14) as BitPack>::Packed

fn unpack(packed: <(U14, U14) as BitPack>::Packed) -> (U14, U14)

impl BitPack for (u8, U52)

type Packed = U60

fn pack(self) -> <(u8, U52) as BitPack>::Packed

fn unpack(packed: <(u8, U52) as BitPack>::Packed) -> (u8, U52)

impl BitPack for (U35, U19)

type Packed = U54

fn pack(self) -> <(U35, U19) as BitPack>::Packed

fn unpack(packed: <(U35, U19) as BitPack>::Packed) -> (U35, U19)

impl BitPack for (U53, U4)

type Packed = U57

fn pack(self) -> <(U53, U4) as BitPack>::Packed

fn unpack(packed: <(U53, U4) as BitPack>::Packed) -> (U53, U4)

impl BitPack for (U24, U27)

type Packed = U51

fn pack(self) -> <(U24, U27) as BitPack>::Packed

fn unpack(packed: <(U24, U27) as BitPack>::Packed) -> (U24, U27)

impl BitPack for (u32, u32)

type Packed = u64

fn pack(self) -> <(u32, u32) as BitPack>::Packed

fn unpack(packed: <(u32, u32) as BitPack>::Packed) -> (u32, u32)

impl BitPack for (U19, U14)

type Packed = U33

fn pack(self) -> <(U19, U14) as BitPack>::Packed

fn unpack(packed: <(U19, U14) as BitPack>::Packed) -> (U19, U14)

impl BitPack for (u8, U38)

type Packed = U46

fn pack(self) -> <(u8, U38) as BitPack>::Packed

fn unpack(packed: <(u8, U38) as BitPack>::Packed) -> (u8, U38)

impl BitPack for (u8, U45)

type Packed = U53

fn pack(self) -> <(u8, U45) as BitPack>::Packed

fn unpack(packed: <(u8, U45) as BitPack>::Packed) -> (u8, U45)

impl BitPack for (U1, U13)

type Packed = U14

fn pack(self) -> <(U1, U13) as BitPack>::Packed

fn unpack(packed: <(U1, U13) as BitPack>::Packed) -> (U1, U13)

impl BitPack for (U24, U39)

type Packed = U63

fn pack(self) -> <(U24, U39) as BitPack>::Packed

fn unpack(packed: <(U24, U39) as BitPack>::Packed) -> (U24, U39)

impl BitPack for (U12, U30)

type Packed = U42

fn pack(self) -> <(U12, U30) as BitPack>::Packed

fn unpack(packed: <(U12, U30) as BitPack>::Packed) -> (U12, U30)

impl BitPack for (U10, U20)

type Packed = U30

fn pack(self) -> <(U10, U20) as BitPack>::Packed

fn unpack(packed: <(U10, U20) as BitPack>::Packed) -> (U10, U20)

impl BitPack for (U30, U10)

type Packed = U40

fn pack(self) -> <(U30, U10) as BitPack>::Packed

fn unpack(packed: <(U30, U10) as BitPack>::Packed) -> (U30, U10)

impl BitPack for (U21, U1)

type Packed = U22

fn pack(self) -> <(U21, U1) as BitPack>::Packed

fn unpack(packed: <(U21, U1) as BitPack>::Packed) -> (U21, U1)

impl BitPack for (U13, u8)

type Packed = U21

fn pack(self) -> <(U13, u8) as BitPack>::Packed

fn unpack(packed: <(U13, u8) as BitPack>::Packed) -> (U13, u8)

impl BitPack for (U43, U17)

type Packed = U60

fn pack(self) -> <(U43, U17) as BitPack>::Packed

fn unpack(packed: <(U43, U17) as BitPack>::Packed) -> (U43, U17)

impl BitPack for (U34, U26)

type Packed = U60

fn pack(self) -> <(U34, U26) as BitPack>::Packed

fn unpack(packed: <(U34, U26) as BitPack>::Packed) -> (U34, U26)

impl BitPack for (U47, U1)

type Packed = U48

fn pack(self) -> <(U47, U1) as BitPack>::Packed

fn unpack(packed: <(U47, U1) as BitPack>::Packed) -> (U47, U1)

impl BitPack for (U6, U12)

type Packed = U18

fn pack(self) -> <(U6, U12) as BitPack>::Packed

fn unpack(packed: <(U6, U12) as BitPack>::Packed) -> (U6, U12)

impl BitPack for (U30, U15)

type Packed = U45

fn pack(self) -> <(U30, U15) as BitPack>::Packed

fn unpack(packed: <(U30, U15) as BitPack>::Packed) -> (U30, U15)

impl BitPack for (U19, U31)

type Packed = U50

fn pack(self) -> <(U19, U31) as BitPack>::Packed

fn unpack(packed: <(U19, U31) as BitPack>::Packed) -> (U19, U31)

impl BitPack for (U42, U20)

type Packed = U62

fn pack(self) -> <(U42, U20) as BitPack>::Packed

fn unpack(packed: <(U42, U20) as BitPack>::Packed) -> (U42, U20)

impl BitPack for (U25, U6)

type Packed = U31

fn pack(self) -> <(U25, U6) as BitPack>::Packed

fn unpack(packed: <(U25, U6) as BitPack>::Packed) -> (U25, U6)

impl BitPack for (U45, U15)

type Packed = U60

fn pack(self) -> <(U45, U15) as BitPack>::Packed

fn unpack(packed: <(U45, U15) as BitPack>::Packed) -> (U45, U15)

impl BitPack for (U7, U24)

type Packed = U31

fn pack(self) -> <(U7, U24) as BitPack>::Packed

fn unpack(packed: <(U7, U24) as BitPack>::Packed) -> (U7, U24)

impl BitPack for (U35, u8)

type Packed = U43

fn pack(self) -> <(U35, u8) as BitPack>::Packed

fn unpack(packed: <(U35, u8) as BitPack>::Packed) -> (U35, u8)

impl BitPack for (U11, U12)

type Packed = U23

fn pack(self) -> <(U11, U12) as BitPack>::Packed

fn unpack(packed: <(U11, U12) as BitPack>::Packed) -> (U11, U12)

impl BitPack for (U2, U51)

type Packed = U53

fn pack(self) -> <(U2, U51) as BitPack>::Packed

fn unpack(packed: <(U2, U51) as BitPack>::Packed) -> (U2, U51)

impl BitPack for (U42, U6)

type Packed = U48

fn pack(self) -> <(U42, U6) as BitPack>::Packed

fn unpack(packed: <(U42, U6) as BitPack>::Packed) -> (U42, U6)

impl BitPack for (U1, U49)

type Packed = U50

fn pack(self) -> <(U1, U49) as BitPack>::Packed

fn unpack(packed: <(U1, U49) as BitPack>::Packed) -> (U1, U49)

impl BitPack for (U43, U9)

type Packed = U52

fn pack(self) -> <(U43, U9) as BitPack>::Packed

fn unpack(packed: <(U43, U9) as BitPack>::Packed) -> (U43, U9)

impl BitPack for (U9, U3)

type Packed = U12

fn pack(self) -> <(U9, U3) as BitPack>::Packed

fn unpack(packed: <(U9, U3) as BitPack>::Packed) -> (U9, U3)

impl BitPack for (u16, U37)

type Packed = U53

fn pack(self) -> <(u16, U37) as BitPack>::Packed

fn unpack(packed: <(u16, U37) as BitPack>::Packed) -> (u16, U37)

impl BitPack for (U52, U5)

type Packed = U57

fn pack(self) -> <(U52, U5) as BitPack>::Packed

fn unpack(packed: <(U52, U5) as BitPack>::Packed) -> (U52, U5)

impl BitPack for (U27, U7)

type Packed = U34

fn pack(self) -> <(U27, U7) as BitPack>::Packed

fn unpack(packed: <(U27, U7) as BitPack>::Packed) -> (U27, U7)

impl BitPack for (U11, u8)

type Packed = U19

fn pack(self) -> <(U11, u8) as BitPack>::Packed

fn unpack(packed: <(U11, u8) as BitPack>::Packed) -> (U11, u8)

impl BitPack for (U2, U57)

type Packed = U59

fn pack(self) -> <(U2, U57) as BitPack>::Packed

fn unpack(packed: <(U2, U57) as BitPack>::Packed) -> (U2, U57)

impl BitPack for (U31, U11)

type Packed = U42

fn pack(self) -> <(U31, U11) as BitPack>::Packed

fn unpack(packed: <(U31, U11) as BitPack>::Packed) -> (U31, U11)

impl BitPack for (U10, U46)

type Packed = U56

fn pack(self) -> <(U10, U46) as BitPack>::Packed

fn unpack(packed: <(U10, U46) as BitPack>::Packed) -> (U10, U46)

impl BitPack for (U9, U1)

type Packed = U10

fn pack(self) -> <(U9, U1) as BitPack>::Packed

fn unpack(packed: <(U9, U1) as BitPack>::Packed) -> (U9, U1)

impl<T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T19, <(T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T19, <(T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U11, U26)

type Packed = U37

fn pack(self) -> <(U11, U26) as BitPack>::Packed

fn unpack(packed: <(U11, U26) as BitPack>::Packed) -> (U11, U26)

impl BitPack for (U10, U24)

type Packed = U34

fn pack(self) -> <(U10, U24) as BitPack>::Packed

fn unpack(packed: <(U10, U24) as BitPack>::Packed) -> (U10, U24)

impl<T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T28, <(T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T28, <(T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U14, U6)

type Packed = U20

fn pack(self) -> <(U14, U6) as BitPack>::Packed

fn unpack(packed: <(U14, U6) as BitPack>::Packed) -> (U14, U6)

impl BitPack for (U24, U25)

type Packed = U49

fn pack(self) -> <(U24, U25) as BitPack>::Packed

fn unpack(packed: <(U24, U25) as BitPack>::Packed) -> (U24, U25)

impl BitPack for (U31, U15)

type Packed = U46

fn pack(self) -> <(U31, U15) as BitPack>::Packed

fn unpack(packed: <(U31, U15) as BitPack>::Packed) -> (U31, U15)

impl BitPack for (U44, U20)

type Packed = u64

fn pack(self) -> <(U44, U20) as BitPack>::Packed

fn unpack(packed: <(U44, U20) as BitPack>::Packed) -> (U44, U20)

impl BitPack for (u8, U1)

type Packed = U9

fn pack(self) -> <(u8, U1) as BitPack>::Packed

fn unpack(packed: <(u8, U1) as BitPack>::Packed) -> (u8, U1)

impl BitPack for (U18, U11)

type Packed = U29

fn pack(self) -> <(U18, U11) as BitPack>::Packed

fn unpack(packed: <(U18, U11) as BitPack>::Packed) -> (U18, U11)

impl BitPack for (U22, U15)

type Packed = U37

fn pack(self) -> <(U22, U15) as BitPack>::Packed

fn unpack(packed: <(U22, U15) as BitPack>::Packed) -> (U22, U15)

impl BitPack for (U38, U21)

type Packed = U59

fn pack(self) -> <(U38, U21) as BitPack>::Packed

fn unpack(packed: <(U38, U21) as BitPack>::Packed) -> (U38, U21)

impl BitPack for (U41, U6)

type Packed = U47

fn pack(self) -> <(U41, U6) as BitPack>::Packed

fn unpack(packed: <(U41, U6) as BitPack>::Packed) -> (U41, U6)

impl BitPack for (U49, U2)

type Packed = U51

fn pack(self) -> <(U49, U2) as BitPack>::Packed

fn unpack(packed: <(U49, U2) as BitPack>::Packed) -> (U49, U2)

impl BitPack for (u32, U4)

type Packed = U36

fn pack(self) -> <(u32, U4) as BitPack>::Packed

fn unpack(packed: <(u32, U4) as BitPack>::Packed) -> (u32, U4)

impl BitPack for (U43, U13)

type Packed = U56

fn pack(self) -> <(U43, U13) as BitPack>::Packed

fn unpack(packed: <(U43, U13) as BitPack>::Packed) -> (U43, U13)

impl BitPack for (U20, U20)

type Packed = U40

fn pack(self) -> <(U20, U20) as BitPack>::Packed

fn unpack(packed: <(U20, U20) as BitPack>::Packed) -> (U20, U20)

impl BitPack for (U48, U14)

type Packed = U62

fn pack(self) -> <(U48, U14) as BitPack>::Packed

fn unpack(packed: <(U48, U14) as BitPack>::Packed) -> (U48, U14)

impl BitPack for (u32, U31)

type Packed = U63

fn pack(self) -> <(u32, U31) as BitPack>::Packed

fn unpack(packed: <(u32, U31) as BitPack>::Packed) -> (u32, U31)

impl BitPack for (U49, u8)

type Packed = U57

fn pack(self) -> <(U49, u8) as BitPack>::Packed

fn unpack(packed: <(U49, u8) as BitPack>::Packed) -> (U49, u8)

impl BitPack for (U53, U2)

type Packed = U55

fn pack(self) -> <(U53, U2) as BitPack>::Packed

fn unpack(packed: <(U53, U2) as BitPack>::Packed) -> (U53, U2)

impl BitPack for (U34, U23)

type Packed = U57

fn pack(self) -> <(U34, U23) as BitPack>::Packed

fn unpack(packed: <(U34, U23) as BitPack>::Packed) -> (U34, U23)

impl BitPack for (U27, U23)

type Packed = U50

fn pack(self) -> <(U27, U23) as BitPack>::Packed

fn unpack(packed: <(U27, U23) as BitPack>::Packed) -> (U27, U23)

impl BitPack for (U15, u16)

type Packed = U31

fn pack(self) -> <(U15, u16) as BitPack>::Packed

fn unpack(packed: <(U15, u16) as BitPack>::Packed) -> (U15, u16)

impl BitPack for (U11, U21)

type Packed = u32

fn pack(self) -> <(U11, U21) as BitPack>::Packed

fn unpack(packed: <(U11, U21) as BitPack>::Packed) -> (U11, U21)

impl BitPack for (U19, U38)

type Packed = U57

fn pack(self) -> <(U19, U38) as BitPack>::Packed

fn unpack(packed: <(U19, U38) as BitPack>::Packed) -> (U19, U38)

impl BitPack for (U11, U29)

type Packed = U40

fn pack(self) -> <(U11, U29) as BitPack>::Packed

fn unpack(packed: <(U11, U29) as BitPack>::Packed) -> (U11, U29)

impl BitPack for (U13, U26)

type Packed = U39

fn pack(self) -> <(U13, U26) as BitPack>::Packed

fn unpack(packed: <(U13, U26) as BitPack>::Packed) -> (U13, U26)

impl<T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T39, <(T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T39, <(T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U18, U18)

type Packed = U36

fn pack(self) -> <(U18, U18) as BitPack>::Packed

fn unpack(packed: <(U18, U18) as BitPack>::Packed) -> (U18, U18)

impl BitPack for (U33, U14)

type Packed = U47

fn pack(self) -> <(U33, U14) as BitPack>::Packed

fn unpack(packed: <(U33, U14) as BitPack>::Packed) -> (U33, U14)

impl BitPack for (U4, U43)

type Packed = U47

fn pack(self) -> <(U4, U43) as BitPack>::Packed

fn unpack(packed: <(U4, U43) as BitPack>::Packed) -> (U4, U43)

impl BitPack for (U20, U1)

type Packed = U21

fn pack(self) -> <(U20, U1) as BitPack>::Packed

fn unpack(packed: <(U20, U1) as BitPack>::Packed) -> (U20, U1)

impl BitPack for (U31, U6)

type Packed = U37

fn pack(self) -> <(U31, U6) as BitPack>::Packed

fn unpack(packed: <(U31, U6) as BitPack>::Packed) -> (U31, U6)

impl BitPack for (U3, U3)

type Packed = U6

fn pack(self) -> <(U3, U3) as BitPack>::Packed

fn unpack(packed: <(U3, U3) as BitPack>::Packed) -> (U3, U3)

impl BitPack for (U48, U6)

type Packed = U54

fn pack(self) -> <(U48, U6) as BitPack>::Packed

fn unpack(packed: <(U48, U6) as BitPack>::Packed) -> (U48, U6)

impl BitPack for (U10, U33)

type Packed = U43

fn pack(self) -> <(U10, U33) as BitPack>::Packed

fn unpack(packed: <(U10, U33) as BitPack>::Packed) -> (U10, U33)

impl BitPack for (U17, U41)

type Packed = U58

fn pack(self) -> <(U17, U41) as BitPack>::Packed

fn unpack(packed: <(U17, U41) as BitPack>::Packed) -> (U17, U41)

impl BitPack for (U26, U13)

type Packed = U39

fn pack(self) -> <(U26, U13) as BitPack>::Packed

fn unpack(packed: <(U26, U13) as BitPack>::Packed) -> (U26, U13)

impl BitPack for (U27, U10)

type Packed = U37

fn pack(self) -> <(U27, U10) as BitPack>::Packed

fn unpack(packed: <(U27, U10) as BitPack>::Packed) -> (U27, U10)

impl BitPack for (U40, U11)

type Packed = U51

fn pack(self) -> <(U40, U11) as BitPack>::Packed

fn unpack(packed: <(U40, U11) as BitPack>::Packed) -> (U40, U11)

impl BitPack for (U38, U20)

type Packed = U58

fn pack(self) -> <(U38, U20) as BitPack>::Packed

fn unpack(packed: <(U38, U20) as BitPack>::Packed) -> (U38, U20)

impl BitPack for (u16, U43)

type Packed = U59

fn pack(self) -> <(u16, U43) as BitPack>::Packed

fn unpack(packed: <(u16, U43) as BitPack>::Packed) -> (u16, U43)

impl BitPack for (U13, U7)

type Packed = U20

fn pack(self) -> <(U13, U7) as BitPack>::Packed

fn unpack(packed: <(U13, U7) as BitPack>::Packed) -> (U13, U7)

impl BitPack for (U15, U41)

type Packed = U56

fn pack(self) -> <(U15, U41) as BitPack>::Packed

fn unpack(packed: <(U15, U41) as BitPack>::Packed) -> (U15, U41)

impl BitPack for (U12, U13)

type Packed = U25

fn pack(self) -> <(U12, U13) as BitPack>::Packed

fn unpack(packed: <(U12, U13) as BitPack>::Packed) -> (U12, U13)

impl BitPack for (u32, U20)

type Packed = U52

fn pack(self) -> <(u32, U20) as BitPack>::Packed

fn unpack(packed: <(u32, U20) as BitPack>::Packed) -> (u32, U20)

impl BitPack for (U29, U24)

type Packed = U53

fn pack(self) -> <(U29, U24) as BitPack>::Packed

fn unpack(packed: <(U29, U24) as BitPack>::Packed) -> (U29, U24)

impl BitPack for (U43, U14)

type Packed = U57

fn pack(self) -> <(U43, U14) as BitPack>::Packed

fn unpack(packed: <(U43, U14) as BitPack>::Packed) -> (U43, U14)

impl BitPack for (U35, U20)

type Packed = U55

fn pack(self) -> <(U35, U20) as BitPack>::Packed

fn unpack(packed: <(U35, U20) as BitPack>::Packed) -> (U35, U20)

impl BitPack for (U39, U15)

type Packed = U54

fn pack(self) -> <(U39, U15) as BitPack>::Packed

fn unpack(packed: <(U39, U15) as BitPack>::Packed) -> (U39, U15)

impl BitPack for (U1, U48)

type Packed = U49

fn pack(self) -> <(U1, U48) as BitPack>::Packed

fn unpack(packed: <(U1, U48) as BitPack>::Packed) -> (U1, U48)

impl BitPack for (U25, U15)

type Packed = U40

fn pack(self) -> <(U25, U15) as BitPack>::Packed

fn unpack(packed: <(U25, U15) as BitPack>::Packed) -> (U25, U15)

impl BitPack for (U1, U51)

type Packed = U52

fn pack(self) -> <(U1, U51) as BitPack>::Packed

fn unpack(packed: <(U1, U51) as BitPack>::Packed) -> (U1, U51)

impl BitPack for (U24, U22)

type Packed = U46

fn pack(self) -> <(U24, U22) as BitPack>::Packed

fn unpack(packed: <(U24, U22) as BitPack>::Packed) -> (U24, U22)

impl<T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T46, <(T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T46, <(T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U12, U43)

type Packed = U55

fn pack(self) -> <(U12, U43) as BitPack>::Packed

fn unpack(packed: <(U12, U43) as BitPack>::Packed) -> (U12, U43)

impl BitPack for (U31, U1)

type Packed = u32

fn pack(self) -> <(U31, U1) as BitPack>::Packed

fn unpack(packed: <(U31, U1) as BitPack>::Packed) -> (U31, U1)

impl BitPack for (U7, U39)

type Packed = U46

fn pack(self) -> <(U7, U39) as BitPack>::Packed

fn unpack(packed: <(U7, U39) as BitPack>::Packed) -> (U7, U39)

impl BitPack for (U24, u8)

type Packed = u32

fn pack(self) -> <(U24, u8) as BitPack>::Packed

fn unpack(packed: <(U24, u8) as BitPack>::Packed) -> (U24, u8)

impl BitPack for (U10, U50)

type Packed = U60

fn pack(self) -> <(U10, U50) as BitPack>::Packed

fn unpack(packed: <(U10, U50) as BitPack>::Packed) -> (U10, U50)

impl BitPack for (U26, U3)

type Packed = U29

fn pack(self) -> <(U26, U3) as BitPack>::Packed

fn unpack(packed: <(U26, U3) as BitPack>::Packed) -> (U26, U3)

impl BitPack for (U2, U10)

type Packed = U12

fn pack(self) -> <(U2, U10) as BitPack>::Packed

fn unpack(packed: <(U2, U10) as BitPack>::Packed) -> (U2, U10)

impl BitPack for (U49, U1)

type Packed = U50

fn pack(self) -> <(U49, U1) as BitPack>::Packed

fn unpack(packed: <(U49, U1) as BitPack>::Packed) -> (U49, U1)

impl BitPack for (U10, U12)

type Packed = U22

fn pack(self) -> <(U10, U12) as BitPack>::Packed

fn unpack(packed: <(U10, U12) as BitPack>::Packed) -> (U10, U12)

impl BitPack for (U40, U10)

type Packed = U50

fn pack(self) -> <(U40, U10) as BitPack>::Packed

fn unpack(packed: <(U40, U10) as BitPack>::Packed) -> (U40, U10)

impl BitPack for (U3, U39)

type Packed = U42

fn pack(self) -> <(U3, U39) as BitPack>::Packed

fn unpack(packed: <(U3, U39) as BitPack>::Packed) -> (U3, U39)

impl BitPack for (U28, U3)

type Packed = U31

fn pack(self) -> <(U28, U3) as BitPack>::Packed

fn unpack(packed: <(U28, U3) as BitPack>::Packed) -> (U28, U3)

impl BitPack for (U24, U4)

type Packed = U28

fn pack(self) -> <(U24, U4) as BitPack>::Packed

fn unpack(packed: <(U24, U4) as BitPack>::Packed) -> (U24, U4)

impl BitPack for (U18, U17)

type Packed = U35

fn pack(self) -> <(U18, U17) as BitPack>::Packed

fn unpack(packed: <(U18, U17) as BitPack>::Packed) -> (U18, U17)

impl BitPack for (U35, U6)

type Packed = U41

fn pack(self) -> <(U35, U6) as BitPack>::Packed

fn unpack(packed: <(U35, U6) as BitPack>::Packed) -> (U35, U6)

impl BitPack for (U6, U24)

type Packed = U30

fn pack(self) -> <(U6, U24) as BitPack>::Packed

fn unpack(packed: <(U6, U24) as BitPack>::Packed) -> (U6, U24)

impl BitPack for (U19, U39)

type Packed = U58

fn pack(self) -> <(U19, U39) as BitPack>::Packed

fn unpack(packed: <(U19, U39) as BitPack>::Packed) -> (U19, U39)

impl BitPack for (U41, U9)

type Packed = U50

fn pack(self) -> <(U41, U9) as BitPack>::Packed

fn unpack(packed: <(U41, U9) as BitPack>::Packed) -> (U41, U9)

impl BitPack for (U42, U7)

type Packed = U49

fn pack(self) -> <(U42, U7) as BitPack>::Packed

fn unpack(packed: <(U42, U7) as BitPack>::Packed) -> (U42, U7)

impl BitPack for (U7, U29)

type Packed = U36

fn pack(self) -> <(U7, U29) as BitPack>::Packed

fn unpack(packed: <(U7, U29) as BitPack>::Packed) -> (U7, U29)

impl BitPack for (U37, U13)

type Packed = U50

fn pack(self) -> <(U37, U13) as BitPack>::Packed

fn unpack(packed: <(U37, U13) as BitPack>::Packed) -> (U37, U13)

impl<T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T23, <(T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T23, <(T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U39, U22)

type Packed = U61

fn pack(self) -> <(U39, U22) as BitPack>::Packed

fn unpack(packed: <(U39, U22) as BitPack>::Packed) -> (U39, U22)

impl BitPack for (U3, U55)

type Packed = U58

fn pack(self) -> <(U3, U55) as BitPack>::Packed

fn unpack(packed: <(U3, U55) as BitPack>::Packed) -> (U3, U55)

impl BitPack for (U31, U9)

type Packed = U40

fn pack(self) -> <(U31, U9) as BitPack>::Packed

fn unpack(packed: <(U31, U9) as BitPack>::Packed) -> (U31, U9)

impl BitPack for (U23, U11)

type Packed = U34

fn pack(self) -> <(U23, U11) as BitPack>::Packed

fn unpack(packed: <(U23, U11) as BitPack>::Packed) -> (U23, U11)

impl BitPack for (U31, U24)

type Packed = U55

fn pack(self) -> <(U31, U24) as BitPack>::Packed

fn unpack(packed: <(U31, U24) as BitPack>::Packed) -> (U31, U24)

impl BitPack for (U21, U41)

type Packed = U62

fn pack(self) -> <(U21, U41) as BitPack>::Packed

fn unpack(packed: <(U21, U41) as BitPack>::Packed) -> (U21, U41)

impl BitPack for (U15, U43)

type Packed = U58

fn pack(self) -> <(U15, U43) as BitPack>::Packed

fn unpack(packed: <(U15, U43) as BitPack>::Packed) -> (U15, U43)

impl<T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T29, <(T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T29, <(T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U45, U3)

type Packed = U48

fn pack(self) -> <(U45, U3) as BitPack>::Packed

fn unpack(packed: <(U45, U3) as BitPack>::Packed) -> (U45, U3)

impl BitPack for (U9, U11)

type Packed = U20

fn pack(self) -> <(U9, U11) as BitPack>::Packed

fn unpack(packed: <(U9, U11) as BitPack>::Packed) -> (U9, U11)

impl BitPack for (U38, U13)

type Packed = U51

fn pack(self) -> <(U38, U13) as BitPack>::Packed

fn unpack(packed: <(U38, U13) as BitPack>::Packed) -> (U38, U13)

impl BitPack for (U23, U3)

type Packed = U26

fn pack(self) -> <(U23, U3) as BitPack>::Packed

fn unpack(packed: <(U23, U3) as BitPack>::Packed) -> (U23, U3)

impl BitPack for (U21, U15)

type Packed = U36

fn pack(self) -> <(U21, U15) as BitPack>::Packed

fn unpack(packed: <(U21, U15) as BitPack>::Packed) -> (U21, U15)

impl BitPack for (U22, u32)

type Packed = U54

fn pack(self) -> <(U22, u32) as BitPack>::Packed

fn unpack(packed: <(U22, u32) as BitPack>::Packed) -> (U22, u32)

impl BitPack for (U59, U4)

type Packed = U63

fn pack(self) -> <(U59, U4) as BitPack>::Packed

fn unpack(packed: <(U59, U4) as BitPack>::Packed) -> (U59, U4)

impl BitPack for (U37, U1)

type Packed = U38

fn pack(self) -> <(U37, U1) as BitPack>::Packed

fn unpack(packed: <(U37, U1) as BitPack>::Packed) -> (U37, U1)

impl BitPack for (U9, U36)

type Packed = U45

fn pack(self) -> <(U9, U36) as BitPack>::Packed

fn unpack(packed: <(U9, U36) as BitPack>::Packed) -> (U9, U36)

impl BitPack for (U10, U44)

type Packed = U54

fn pack(self) -> <(U10, U44) as BitPack>::Packed

fn unpack(packed: <(U10, U44) as BitPack>::Packed) -> (U10, U44)

impl BitPack for (U34, U13)

type Packed = U47

fn pack(self) -> <(U34, U13) as BitPack>::Packed

fn unpack(packed: <(U34, U13) as BitPack>::Packed) -> (U34, U13)

impl BitPack for (U27, U6)

type Packed = U33

fn pack(self) -> <(U27, U6) as BitPack>::Packed

fn unpack(packed: <(U27, U6) as BitPack>::Packed) -> (U27, U6)

impl BitPack for (U7, U6)

type Packed = U13

fn pack(self) -> <(U7, U6) as BitPack>::Packed

fn unpack(packed: <(U7, U6) as BitPack>::Packed) -> (U7, U6)

impl BitPack for (U52, U10)

type Packed = U62

fn pack(self) -> <(U52, U10) as BitPack>::Packed

fn unpack(packed: <(U52, U10) as BitPack>::Packed) -> (U52, U10)

impl BitPack for (U27, U35)

type Packed = U62

fn pack(self) -> <(U27, U35) as BitPack>::Packed

fn unpack(packed: <(U27, U35) as BitPack>::Packed) -> (U27, U35)

impl BitPack for (U21, U9)

type Packed = U30

fn pack(self) -> <(U21, U9) as BitPack>::Packed

fn unpack(packed: <(U21, U9) as BitPack>::Packed) -> (U21, U9)

impl BitPack for (U18, U6)

type Packed = U24

fn pack(self) -> <(U18, U6) as BitPack>::Packed

fn unpack(packed: <(U18, U6) as BitPack>::Packed) -> (U18, U6)

impl BitPack for (U1, U63)

type Packed = u64

fn pack(self) -> <(U1, U63) as BitPack>::Packed

fn unpack(packed: <(U1, U63) as BitPack>::Packed) -> (U1, U63)

impl BitPack for (U5, U53)

type Packed = U58

fn pack(self) -> <(U5, U53) as BitPack>::Packed

fn unpack(packed: <(U5, U53) as BitPack>::Packed) -> (U5, U53)

impl BitPack for (U12, U23)

type Packed = U35

fn pack(self) -> <(U12, U23) as BitPack>::Packed

fn unpack(packed: <(U12, U23) as BitPack>::Packed) -> (U12, U23)

impl BitPack for (U52, U6)

type Packed = U58

fn pack(self) -> <(U52, U6) as BitPack>::Packed

fn unpack(packed: <(U52, U6) as BitPack>::Packed) -> (U52, U6)

impl BitPack for (U23, U19)

type Packed = U42

fn pack(self) -> <(U23, U19) as BitPack>::Packed

fn unpack(packed: <(U23, U19) as BitPack>::Packed) -> (U23, U19)

impl BitPack for (U9, u16)

type Packed = U25

fn pack(self) -> <(U9, u16) as BitPack>::Packed

fn unpack(packed: <(U9, u16) as BitPack>::Packed) -> (U9, u16)

impl BitPack for (U1, U21)

type Packed = U22

fn pack(self) -> <(U1, U21) as BitPack>::Packed

fn unpack(packed: <(U1, U21) as BitPack>::Packed) -> (U1, U21)

impl BitPack for (U42, U5)

type Packed = U47

fn pack(self) -> <(U42, U5) as BitPack>::Packed

fn unpack(packed: <(U42, U5) as BitPack>::Packed) -> (U42, U5)

impl<T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T35, <(T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T35, <(T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U5, U9)

type Packed = U14

fn pack(self) -> <(U5, U9) as BitPack>::Packed

fn unpack(packed: <(U5, U9) as BitPack>::Packed) -> (U5, U9)

impl BitPack for (U11, U15)

type Packed = U26

fn pack(self) -> <(U11, U15) as BitPack>::Packed

fn unpack(packed: <(U11, U15) as BitPack>::Packed) -> (U11, U15)

impl BitPack for (U46, U6)

type Packed = U52

fn pack(self) -> <(U46, U6) as BitPack>::Packed

fn unpack(packed: <(U46, U6) as BitPack>::Packed) -> (U46, U6)

impl BitPack for (U39, u16)

type Packed = U55

fn pack(self) -> <(U39, u16) as BitPack>::Packed

fn unpack(packed: <(U39, u16) as BitPack>::Packed) -> (U39, u16)

impl BitPack for (U12, U1)

type Packed = U13

fn pack(self) -> <(U12, U1) as BitPack>::Packed

fn unpack(packed: <(U12, U1) as BitPack>::Packed) -> (U12, U1)

impl BitPack for (U17, U39)

type Packed = U56

fn pack(self) -> <(U17, U39) as BitPack>::Packed

fn unpack(packed: <(U17, U39) as BitPack>::Packed) -> (U17, U39)

impl BitPack for (U23, U6)

type Packed = U29

fn pack(self) -> <(U23, U6) as BitPack>::Packed

fn unpack(packed: <(U23, U6) as BitPack>::Packed) -> (U23, U6)

impl BitPack for (U36, U14)

type Packed = U50

fn pack(self) -> <(U36, U14) as BitPack>::Packed

fn unpack(packed: <(U36, U14) as BitPack>::Packed) -> (U36, U14)

impl BitPack for (U31, U31)

type Packed = U62

fn pack(self) -> <(U31, U31) as BitPack>::Packed

fn unpack(packed: <(U31, U31) as BitPack>::Packed) -> (U31, U31)

impl BitPack for (U60, U1)

type Packed = U61

fn pack(self) -> <(U60, U1) as BitPack>::Packed

fn unpack(packed: <(U60, U1) as BitPack>::Packed) -> (U60, U1)

impl BitPack for (U51, u8)

type Packed = U59

fn pack(self) -> <(U51, u8) as BitPack>::Packed

fn unpack(packed: <(U51, u8) as BitPack>::Packed) -> (U51, u8)

impl BitPack for (U53, U7)

type Packed = U60

fn pack(self) -> <(U53, U7) as BitPack>::Packed

fn unpack(packed: <(U53, U7) as BitPack>::Packed) -> (U53, U7)

impl BitPack for (U39, U25)

type Packed = u64

fn pack(self) -> <(U39, U25) as BitPack>::Packed

fn unpack(packed: <(U39, U25) as BitPack>::Packed) -> (U39, U25)

impl BitPack for (U5, U25)

type Packed = U30

fn pack(self) -> <(U5, U25) as BitPack>::Packed

fn unpack(packed: <(U5, U25) as BitPack>::Packed) -> (U5, U25)

impl BitPack for (U47, U12)

type Packed = U59

fn pack(self) -> <(U47, U12) as BitPack>::Packed

fn unpack(packed: <(U47, U12) as BitPack>::Packed) -> (U47, U12)

impl BitPack for (U1, U24)

type Packed = U25

fn pack(self) -> <(U1, U24) as BitPack>::Packed

fn unpack(packed: <(U1, U24) as BitPack>::Packed) -> (U1, U24)

impl BitPack for (U19, u16)

type Packed = U35

fn pack(self) -> <(U19, u16) as BitPack>::Packed

fn unpack(packed: <(U19, u16) as BitPack>::Packed) -> (U19, u16)

impl BitPack for (U23, U38)

type Packed = U61

fn pack(self) -> <(U23, U38) as BitPack>::Packed

fn unpack(packed: <(U23, U38) as BitPack>::Packed) -> (U23, U38)

impl BitPack for (U58, U5)

type Packed = U63

fn pack(self) -> <(U58, U5) as BitPack>::Packed

fn unpack(packed: <(U58, U5) as BitPack>::Packed) -> (U58, U5)

impl BitPack for (U37, U23)

type Packed = U60

fn pack(self) -> <(U37, U23) as BitPack>::Packed

fn unpack(packed: <(U37, U23) as BitPack>::Packed) -> (U37, U23)

impl BitPack for (U11, U48)

type Packed = U59

fn pack(self) -> <(U11, U48) as BitPack>::Packed

fn unpack(packed: <(U11, U48) as BitPack>::Packed) -> (U11, U48)

impl BitPack for (U39, U11)

type Packed = U50

fn pack(self) -> <(U39, U11) as BitPack>::Packed

fn unpack(packed: <(U39, U11) as BitPack>::Packed) -> (U39, U11)

impl BitPack for (U33, U29)

type Packed = U62

fn pack(self) -> <(U33, U29) as BitPack>::Packed

fn unpack(packed: <(U33, U29) as BitPack>::Packed) -> (U33, U29)

impl BitPack for (U51, U13)

type Packed = u64

fn pack(self) -> <(U51, U13) as BitPack>::Packed

fn unpack(packed: <(U51, U13) as BitPack>::Packed) -> (U51, U13)

impl BitPack for (U27, U30)

type Packed = U57

fn pack(self) -> <(U27, U30) as BitPack>::Packed

fn unpack(packed: <(U27, U30) as BitPack>::Packed) -> (U27, U30)

impl BitPack for (U5, U2)

type Packed = U7

fn pack(self) -> <(U5, U2) as BitPack>::Packed

fn unpack(packed: <(U5, U2) as BitPack>::Packed) -> (U5, U2)

impl BitPack for (U43, U20)

type Packed = U63

fn pack(self) -> <(U43, U20) as BitPack>::Packed

fn unpack(packed: <(U43, U20) as BitPack>::Packed) -> (U43, U20)

impl BitPack for (U11, U20)

type Packed = U31

fn pack(self) -> <(U11, U20) as BitPack>::Packed

fn unpack(packed: <(U11, U20) as BitPack>::Packed) -> (U11, U20)

impl BitPack for (U9, U6)

type Packed = U15

fn pack(self) -> <(U9, U6) as BitPack>::Packed

fn unpack(packed: <(U9, U6) as BitPack>::Packed) -> (U9, U6)

impl BitPack for (U15, U25)

type Packed = U40

fn pack(self) -> <(U15, U25) as BitPack>::Packed

fn unpack(packed: <(U15, U25) as BitPack>::Packed) -> (U15, U25)

impl BitPack for (U2, U48)

type Packed = U50

fn pack(self) -> <(U2, U48) as BitPack>::Packed

fn unpack(packed: <(U2, U48) as BitPack>::Packed) -> (U2, U48)

impl BitPack for (U26, U7)

type Packed = U33

fn pack(self) -> <(U26, U7) as BitPack>::Packed

fn unpack(packed: <(U26, U7) as BitPack>::Packed) -> (U26, U7)

impl BitPack for (U3, U12)

type Packed = U15

fn pack(self) -> <(U3, U12) as BitPack>::Packed

fn unpack(packed: <(U3, U12) as BitPack>::Packed) -> (U3, U12)

impl<T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T26, <(T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T26, <(T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U12, U28)

type Packed = U40

fn pack(self) -> <(U12, U28) as BitPack>::Packed

fn unpack(packed: <(U12, U28) as BitPack>::Packed) -> (U12, U28)

impl<T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T56, <(T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T56, <(T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U55, u8)

type Packed = U63

fn pack(self) -> <(U55, u8) as BitPack>::Packed

fn unpack(packed: <(U55, u8) as BitPack>::Packed) -> (U55, u8)

impl BitPack for (U56, U2)

type Packed = U58

fn pack(self) -> <(U56, U2) as BitPack>::Packed

fn unpack(packed: <(U56, U2) as BitPack>::Packed) -> (U56, U2)

impl BitPack for (U35, U27)

type Packed = U62

fn pack(self) -> <(U35, U27) as BitPack>::Packed

fn unpack(packed: <(U35, U27) as BitPack>::Packed) -> (U35, U27)

impl BitPack for (U3, U7)

type Packed = U10

fn pack(self) -> <(U3, U7) as BitPack>::Packed

fn unpack(packed: <(U3, U7) as BitPack>::Packed) -> (U3, U7)

impl BitPack for (U20, U6)

type Packed = U26

fn pack(self) -> <(U20, U6) as BitPack>::Packed

fn unpack(packed: <(U20, U6) as BitPack>::Packed) -> (U20, U6)

impl BitPack for (U44, U10)

type Packed = U54

fn pack(self) -> <(U44, U10) as BitPack>::Packed

fn unpack(packed: <(U44, U10) as BitPack>::Packed) -> (U44, U10)

impl BitPack for (U19, U44)

type Packed = U63

fn pack(self) -> <(U19, U44) as BitPack>::Packed

fn unpack(packed: <(U19, U44) as BitPack>::Packed) -> (U19, U44)

impl BitPack for (U38, U2)

type Packed = U40

fn pack(self) -> <(U38, U2) as BitPack>::Packed

fn unpack(packed: <(U38, U2) as BitPack>::Packed) -> (U38, U2)

impl BitPack for (U49, U12)

type Packed = U61

fn pack(self) -> <(U49, U12) as BitPack>::Packed

fn unpack(packed: <(U49, U12) as BitPack>::Packed) -> (U49, U12)

impl BitPack for (U13, U45)

type Packed = U58

fn pack(self) -> <(U13, U45) as BitPack>::Packed

fn unpack(packed: <(U13, U45) as BitPack>::Packed) -> (U13, U45)

impl BitPack for (U26, U15)

type Packed = U41

fn pack(self) -> <(U26, U15) as BitPack>::Packed

fn unpack(packed: <(U26, U15) as BitPack>::Packed) -> (U26, U15)

impl BitPack for (U28, U21)

type Packed = U49

fn pack(self) -> <(U28, U21) as BitPack>::Packed

fn unpack(packed: <(U28, U21) as BitPack>::Packed) -> (U28, U21)

impl BitPack for (U14, U9)

type Packed = U23

fn pack(self) -> <(U14, U9) as BitPack>::Packed

fn unpack(packed: <(U14, U9) as BitPack>::Packed) -> (U14, U9)

impl BitPack for (U19, U18)

type Packed = U37

fn pack(self) -> <(U19, U18) as BitPack>::Packed

fn unpack(packed: <(U19, U18) as BitPack>::Packed) -> (U19, U18)

impl BitPack for (U11, U34)

type Packed = U45

fn pack(self) -> <(U11, U34) as BitPack>::Packed

fn unpack(packed: <(U11, U34) as BitPack>::Packed) -> (U11, U34)

impl BitPack for (U30, U11)

type Packed = U41

fn pack(self) -> <(U30, U11) as BitPack>::Packed

fn unpack(packed: <(U30, U11) as BitPack>::Packed) -> (U30, U11)

impl BitPack for (u16, U29)

type Packed = U45

fn pack(self) -> <(u16, U29) as BitPack>::Packed

fn unpack(packed: <(u16, U29) as BitPack>::Packed) -> (u16, U29)

impl BitPack for (U25, U14)

type Packed = U39

fn pack(self) -> <(U25, U14) as BitPack>::Packed

fn unpack(packed: <(U25, U14) as BitPack>::Packed) -> (U25, U14)

impl BitPack for (U3, U21)

type Packed = U24

fn pack(self) -> <(U3, U21) as BitPack>::Packed

fn unpack(packed: <(U3, U21) as BitPack>::Packed) -> (U3, U21)

impl BitPack for (U26, U34)

type Packed = U60

fn pack(self) -> <(U26, U34) as BitPack>::Packed

fn unpack(packed: <(U26, U34) as BitPack>::Packed) -> (U26, U34)

impl BitPack for (U5, U44)

type Packed = U49

fn pack(self) -> <(U5, U44) as BitPack>::Packed

fn unpack(packed: <(U5, U44) as BitPack>::Packed) -> (U5, U44)

impl BitPack for (U5, U48)

type Packed = U53

fn pack(self) -> <(U5, U48) as BitPack>::Packed

fn unpack(packed: <(U5, U48) as BitPack>::Packed) -> (U5, U48)

impl BitPack for (u8, U13)

type Packed = U21

fn pack(self) -> <(u8, U13) as BitPack>::Packed

fn unpack(packed: <(u8, U13) as BitPack>::Packed) -> (u8, U13)

impl BitPack for (U6, U18)

type Packed = U24

fn pack(self) -> <(U6, U18) as BitPack>::Packed

fn unpack(packed: <(U6, U18) as BitPack>::Packed) -> (U6, U18)

impl BitPack for (U18, U19)

type Packed = U37

fn pack(self) -> <(U18, U19) as BitPack>::Packed

fn unpack(packed: <(U18, U19) as BitPack>::Packed) -> (U18, U19)

impl BitPack for (U41, U23)

type Packed = u64

fn pack(self) -> <(U41, U23) as BitPack>::Packed

fn unpack(packed: <(U41, U23) as BitPack>::Packed) -> (U41, U23)

impl BitPack for (U22, U29)

type Packed = U51

fn pack(self) -> <(U22, U29) as BitPack>::Packed

fn unpack(packed: <(U22, U29) as BitPack>::Packed) -> (U22, U29)

impl BitPack for (U21, U31)

type Packed = U52

fn pack(self) -> <(U21, U31) as BitPack>::Packed

fn unpack(packed: <(U21, U31) as BitPack>::Packed) -> (U21, U31)

impl BitPack for (U3, U29)

type Packed = u32

fn pack(self) -> <(U3, U29) as BitPack>::Packed

fn unpack(packed: <(U3, U29) as BitPack>::Packed) -> (U3, U29)

impl BitPack for (U3, U24)

type Packed = U27

fn pack(self) -> <(U3, U24) as BitPack>::Packed

fn unpack(packed: <(U3, U24) as BitPack>::Packed) -> (U3, U24)

impl BitPack for (U5, U1)

type Packed = U6

fn pack(self) -> <(U5, U1) as BitPack>::Packed

fn unpack(packed: <(U5, U1) as BitPack>::Packed) -> (U5, U1)

impl BitPack for (U11, u16)

type Packed = U27

fn pack(self) -> <(U11, u16) as BitPack>::Packed

fn unpack(packed: <(U11, u16) as BitPack>::Packed) -> (U11, u16)

impl BitPack for (U54, U5)

type Packed = U59

fn pack(self) -> <(U54, U5) as BitPack>::Packed

fn unpack(packed: <(U54, U5) as BitPack>::Packed) -> (U54, U5)

impl BitPack for (U6, u8)

type Packed = U14

fn pack(self) -> <(U6, u8) as BitPack>::Packed

fn unpack(packed: <(U6, u8) as BitPack>::Packed) -> (U6, u8)

impl BitPack for (U5, U57)

type Packed = U62

fn pack(self) -> <(U5, U57) as BitPack>::Packed

fn unpack(packed: <(U5, U57) as BitPack>::Packed) -> (U5, U57)

impl BitPack for (U30, U22)

type Packed = U52

fn pack(self) -> <(U30, U22) as BitPack>::Packed

fn unpack(packed: <(U30, U22) as BitPack>::Packed) -> (U30, U22)

impl BitPack for (U14, U39)

type Packed = U53

fn pack(self) -> <(U14, U39) as BitPack>::Packed

fn unpack(packed: <(U14, U39) as BitPack>::Packed) -> (U14, U39)

impl BitPack for (U37, u8)

type Packed = U45

fn pack(self) -> <(U37, u8) as BitPack>::Packed

fn unpack(packed: <(U37, u8) as BitPack>::Packed) -> (U37, u8)

impl BitPack for (U7, U15)

type Packed = U22

fn pack(self) -> <(U7, U15) as BitPack>::Packed

fn unpack(packed: <(U7, U15) as BitPack>::Packed) -> (U7, U15)

impl BitPack for (U10, U27)

type Packed = U37

fn pack(self) -> <(U10, U27) as BitPack>::Packed

fn unpack(packed: <(U10, U27) as BitPack>::Packed) -> (U10, U27)

impl BitPack for (U10, U26)

type Packed = U36

fn pack(self) -> <(U10, U26) as BitPack>::Packed

fn unpack(packed: <(U10, U26) as BitPack>::Packed) -> (U10, U26)

impl BitPack for (U11, U36)

type Packed = U47

fn pack(self) -> <(U11, U36) as BitPack>::Packed

fn unpack(packed: <(U11, U36) as BitPack>::Packed) -> (U11, U36)

impl BitPack for (U20, U3)

type Packed = U23

fn pack(self) -> <(U20, U3) as BitPack>::Packed

fn unpack(packed: <(U20, U3) as BitPack>::Packed) -> (U20, U3)

impl BitPack for (U39, U20)

type Packed = U59

fn pack(self) -> <(U39, U20) as BitPack>::Packed

fn unpack(packed: <(U39, U20) as BitPack>::Packed) -> (U39, U20)

impl BitPack for (U30, U2)

type Packed = u32

fn pack(self) -> <(U30, U2) as BitPack>::Packed

fn unpack(packed: <(U30, U2) as BitPack>::Packed) -> (U30, U2)

impl BitPack for (U9, U20)

type Packed = U29

fn pack(self) -> <(U9, U20) as BitPack>::Packed

fn unpack(packed: <(U9, U20) as BitPack>::Packed) -> (U9, U20)

impl BitPack for (U5, U17)

type Packed = U22

fn pack(self) -> <(U5, U17) as BitPack>::Packed

fn unpack(packed: <(U5, U17) as BitPack>::Packed) -> (U5, U17)

impl BitPack for (U57, U6)

type Packed = U63

fn pack(self) -> <(U57, U6) as BitPack>::Packed

fn unpack(packed: <(U57, U6) as BitPack>::Packed) -> (U57, U6)

impl BitPack for (U34, U25)

type Packed = U59

fn pack(self) -> <(U34, U25) as BitPack>::Packed

fn unpack(packed: <(U34, U25) as BitPack>::Packed) -> (U34, U25)

impl BitPack for (u32, U5)

type Packed = U37

fn pack(self) -> <(u32, U5) as BitPack>::Packed

fn unpack(packed: <(u32, U5) as BitPack>::Packed) -> (u32, U5)

impl BitPack for (U44, U14)

type Packed = U58

fn pack(self) -> <(U44, U14) as BitPack>::Packed

fn unpack(packed: <(U44, U14) as BitPack>::Packed) -> (U44, U14)

impl BitPack for (U23, U39)

type Packed = U62

fn pack(self) -> <(U23, U39) as BitPack>::Packed

fn unpack(packed: <(U23, U39) as BitPack>::Packed) -> (U23, U39)

impl BitPack for (U10, U42)

type Packed = U52

fn pack(self) -> <(U10, U42) as BitPack>::Packed

fn unpack(packed: <(U10, U42) as BitPack>::Packed) -> (U10, U42)

impl BitPack for (U26, u32)

type Packed = U58

fn pack(self) -> <(U26, u32) as BitPack>::Packed

fn unpack(packed: <(U26, u32) as BitPack>::Packed) -> (U26, u32)

impl BitPack for (U12, u32)

type Packed = U44

fn pack(self) -> <(U12, u32) as BitPack>::Packed

fn unpack(packed: <(U12, u32) as BitPack>::Packed) -> (U12, u32)

impl BitPack for (U9, U17)

type Packed = U26

fn pack(self) -> <(U9, U17) as BitPack>::Packed

fn unpack(packed: <(U9, U17) as BitPack>::Packed) -> (U9, U17)

impl BitPack for (U40, U4)

type Packed = U44

fn pack(self) -> <(U40, U4) as BitPack>::Packed

fn unpack(packed: <(U40, U4) as BitPack>::Packed) -> (U40, U4)

impl BitPack for (U13, U4)

type Packed = U17

fn pack(self) -> <(U13, U4) as BitPack>::Packed

fn unpack(packed: <(U13, U4) as BitPack>::Packed) -> (U13, U4)

impl BitPack for (u8, U5)

type Packed = U13

fn pack(self) -> <(u8, U5) as BitPack>::Packed

fn unpack(packed: <(u8, U5) as BitPack>::Packed) -> (u8, U5)

impl BitPack for (U18, U10)

type Packed = U28

fn pack(self) -> <(U18, U10) as BitPack>::Packed

fn unpack(packed: <(U18, U10) as BitPack>::Packed) -> (U18, U10)

impl BitPack for (U4, U12)

type Packed = u16

fn pack(self) -> <(U4, U12) as BitPack>::Packed

fn unpack(packed: <(U4, U12) as BitPack>::Packed) -> (U4, U12)

impl BitPack for (U3, U40)

type Packed = U43

fn pack(self) -> <(U3, U40) as BitPack>::Packed

fn unpack(packed: <(U3, U40) as BitPack>::Packed) -> (U3, U40)

impl BitPack for (U24, U24)

type Packed = U48

fn pack(self) -> <(U24, U24) as BitPack>::Packed

fn unpack(packed: <(U24, U24) as BitPack>::Packed) -> (U24, U24)

impl BitPack for (U6, U7)

type Packed = U13

fn pack(self) -> <(U6, U7) as BitPack>::Packed

fn unpack(packed: <(U6, U7) as BitPack>::Packed) -> (U6, U7)

impl BitPack for (u8, U56)

type Packed = u64

fn pack(self) -> <(u8, U56) as BitPack>::Packed

fn unpack(packed: <(u8, U56) as BitPack>::Packed) -> (u8, U56)

impl BitPack for (U41, U4)

type Packed = U45

fn pack(self) -> <(U41, U4) as BitPack>::Packed

fn unpack(packed: <(U41, U4) as BitPack>::Packed) -> (U41, U4)

impl BitPack for (U19, U7)

type Packed = U26

fn pack(self) -> <(U19, U7) as BitPack>::Packed

fn unpack(packed: <(U19, U7) as BitPack>::Packed) -> (U19, U7)

impl BitPack for (u16, U41)

type Packed = U57

fn pack(self) -> <(u16, U41) as BitPack>::Packed

fn unpack(packed: <(u16, U41) as BitPack>::Packed) -> (u16, U41)

impl BitPack for (U26, U1)

type Packed = U27

fn pack(self) -> <(U26, U1) as BitPack>::Packed

fn unpack(packed: <(U26, U1) as BitPack>::Packed) -> (U26, U1)

impl BitPack for (U5, U35)

type Packed = U40

fn pack(self) -> <(U5, U35) as BitPack>::Packed

fn unpack(packed: <(U5, U35) as BitPack>::Packed) -> (U5, U35)

impl BitPack for (U12, U46)

type Packed = U58

fn pack(self) -> <(U12, U46) as BitPack>::Packed

fn unpack(packed: <(U12, U46) as BitPack>::Packed) -> (U12, U46)

impl<T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T6, <(T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T6, <(T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U28, U30)

type Packed = U58

fn pack(self) -> <(U28, U30) as BitPack>::Packed

fn unpack(packed: <(U28, U30) as BitPack>::Packed) -> (U28, U30)

impl BitPack for (U14, U18)

type Packed = u32

fn pack(self) -> <(U14, U18) as BitPack>::Packed

fn unpack(packed: <(U14, U18) as BitPack>::Packed) -> (U14, U18)

impl BitPack for (U7, U33)

type Packed = U40

fn pack(self) -> <(U7, U33) as BitPack>::Packed

fn unpack(packed: <(U7, U33) as BitPack>::Packed) -> (U7, U33)

impl BitPack for (U18, U41)

type Packed = U59

fn pack(self) -> <(U18, U41) as BitPack>::Packed

fn unpack(packed: <(U18, U41) as BitPack>::Packed) -> (U18, U41)

impl BitPack for (U44, U12)

type Packed = U56

fn pack(self) -> <(U44, U12) as BitPack>::Packed

fn unpack(packed: <(U44, U12) as BitPack>::Packed) -> (U44, U12)

impl BitPack for (U9, U55)

type Packed = u64

fn pack(self) -> <(U9, U55) as BitPack>::Packed

fn unpack(packed: <(U9, U55) as BitPack>::Packed) -> (U9, U55)

impl BitPack for (U1, u8)

type Packed = U9

fn pack(self) -> <(U1, u8) as BitPack>::Packed

fn unpack(packed: <(U1, u8) as BitPack>::Packed) -> (U1, u8)

impl BitPack for (U28, U1)

type Packed = U29

fn pack(self) -> <(U28, U1) as BitPack>::Packed

fn unpack(packed: <(U28, U1) as BitPack>::Packed) -> (U28, U1)

impl BitPack for (u8, U31)

type Packed = U39

fn pack(self) -> <(u8, U31) as BitPack>::Packed

fn unpack(packed: <(u8, U31) as BitPack>::Packed) -> (u8, U31)

impl BitPack for (U37, U20)

type Packed = U57

fn pack(self) -> <(U37, U20) as BitPack>::Packed

fn unpack(packed: <(U37, U20) as BitPack>::Packed) -> (U37, U20)

impl BitPack for (U7, U35)

type Packed = U42

fn pack(self) -> <(U7, U35) as BitPack>::Packed

fn unpack(packed: <(U7, U35) as BitPack>::Packed) -> (U7, U35)

impl BitPack for (U22, U42)

type Packed = u64

fn pack(self) -> <(U22, U42) as BitPack>::Packed

fn unpack(packed: <(U22, U42) as BitPack>::Packed) -> (U22, U42)

impl BitPack for (U35, u16)

type Packed = U51

fn pack(self) -> <(U35, u16) as BitPack>::Packed

fn unpack(packed: <(U35, u16) as BitPack>::Packed) -> (U35, u16)

impl BitPack for (U7, U48)

type Packed = U55

fn pack(self) -> <(U7, U48) as BitPack>::Packed

fn unpack(packed: <(U7, U48) as BitPack>::Packed) -> (U7, U48)

impl BitPack for (U20, U23)

type Packed = U43

fn pack(self) -> <(U20, U23) as BitPack>::Packed

fn unpack(packed: <(U20, U23) as BitPack>::Packed) -> (U20, U23)

impl BitPack for (U12, U51)

type Packed = U63

fn pack(self) -> <(U12, U51) as BitPack>::Packed

fn unpack(packed: <(U12, U51) as BitPack>::Packed) -> (U12, U51)

impl BitPack for (U35, U13)

type Packed = U48

fn pack(self) -> <(U35, U13) as BitPack>::Packed

fn unpack(packed: <(U35, U13) as BitPack>::Packed) -> (U35, U13)

impl BitPack for (U7, U26)

type Packed = U33

fn pack(self) -> <(U7, U26) as BitPack>::Packed

fn unpack(packed: <(U7, U26) as BitPack>::Packed) -> (U7, U26)

impl BitPack for (U11, U38)

type Packed = U49

fn pack(self) -> <(U11, U38) as BitPack>::Packed

fn unpack(packed: <(U11, U38) as BitPack>::Packed) -> (U11, U38)

impl BitPack for (U27, U17)

type Packed = U44

fn pack(self) -> <(U27, U17) as BitPack>::Packed

fn unpack(packed: <(U27, U17) as BitPack>::Packed) -> (U27, U17)

impl BitPack for (U12, U42)

type Packed = U54

fn pack(self) -> <(U12, U42) as BitPack>::Packed

fn unpack(packed: <(U12, U42) as BitPack>::Packed) -> (U12, U42)

impl BitPack for (U11, U39)

type Packed = U50

fn pack(self) -> <(U11, U39) as BitPack>::Packed

fn unpack(packed: <(U11, U39) as BitPack>::Packed) -> (U11, U39)

impl BitPack for (U39, U1)

type Packed = U40

fn pack(self) -> <(U39, U1) as BitPack>::Packed

fn unpack(packed: <(U39, U1) as BitPack>::Packed) -> (U39, U1)

impl BitPack for (U1, U3)

type Packed = U4

fn pack(self) -> <(U1, U3) as BitPack>::Packed

fn unpack(packed: <(U1, U3) as BitPack>::Packed) -> (U1, U3)

impl BitPack for (U20, U15)

type Packed = U35

fn pack(self) -> <(U20, U15) as BitPack>::Packed

fn unpack(packed: <(U20, U15) as BitPack>::Packed) -> (U20, U15)

impl BitPack for (U5, U54)

type Packed = U59

fn pack(self) -> <(U5, U54) as BitPack>::Packed

fn unpack(packed: <(U5, U54) as BitPack>::Packed) -> (U5, U54)

impl BitPack for (U29, U33)

type Packed = U62

fn pack(self) -> <(U29, U33) as BitPack>::Packed

fn unpack(packed: <(U29, U33) as BitPack>::Packed) -> (U29, U33)

impl BitPack for (U4, U36)

type Packed = U40

fn pack(self) -> <(U4, U36) as BitPack>::Packed

fn unpack(packed: <(U4, U36) as BitPack>::Packed) -> (U4, U36)

impl BitPack for (u32, U11)

type Packed = U43

fn pack(self) -> <(u32, U11) as BitPack>::Packed

fn unpack(packed: <(u32, U11) as BitPack>::Packed) -> (u32, U11)

impl BitPack for (U2, U37)

type Packed = U39

fn pack(self) -> <(U2, U37) as BitPack>::Packed

fn unpack(packed: <(U2, U37) as BitPack>::Packed) -> (U2, U37)

impl BitPack for (U12, U36)

type Packed = U48

fn pack(self) -> <(U12, U36) as BitPack>::Packed

fn unpack(packed: <(U12, U36) as BitPack>::Packed) -> (U12, U36)

impl<T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T13, <(T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T13, <(T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U28, u16)

type Packed = U44

fn pack(self) -> <(U28, u16) as BitPack>::Packed

fn unpack(packed: <(U28, u16) as BitPack>::Packed) -> (U28, u16)

impl BitPack for (U7, U45)

type Packed = U52

fn pack(self) -> <(U7, U45) as BitPack>::Packed

fn unpack(packed: <(U7, U45) as BitPack>::Packed) -> (U7, U45)

impl BitPack for (U21, U14)

type Packed = U35

fn pack(self) -> <(U21, U14) as BitPack>::Packed

fn unpack(packed: <(U21, U14) as BitPack>::Packed) -> (U21, U14)

impl BitPack for (U22, U21)

type Packed = U43

fn pack(self) -> <(U22, U21) as BitPack>::Packed

fn unpack(packed: <(U22, U21) as BitPack>::Packed) -> (U22, U21)

impl BitPack for (U33, U10)

type Packed = U43

fn pack(self) -> <(U33, U10) as BitPack>::Packed

fn unpack(packed: <(U33, U10) as BitPack>::Packed) -> (U33, U10)

impl BitPack for (U42, U9)

type Packed = U51

fn pack(self) -> <(U42, U9) as BitPack>::Packed

fn unpack(packed: <(U42, U9) as BitPack>::Packed) -> (U42, U9)

impl BitPack for (U2, U31)

type Packed = U33

fn pack(self) -> <(U2, U31) as BitPack>::Packed

fn unpack(packed: <(U2, U31) as BitPack>::Packed) -> (U2, U31)

impl BitPack for (U18, U29)

type Packed = U47

fn pack(self) -> <(U18, U29) as BitPack>::Packed

fn unpack(packed: <(U18, U29) as BitPack>::Packed) -> (U18, U29)

impl BitPack for (U29, U10)

type Packed = U39

fn pack(self) -> <(U29, U10) as BitPack>::Packed

fn unpack(packed: <(U29, U10) as BitPack>::Packed) -> (U29, U10)

impl BitPack for (U18, U27)

type Packed = U45

fn pack(self) -> <(U18, U27) as BitPack>::Packed

fn unpack(packed: <(U18, U27) as BitPack>::Packed) -> (U18, U27)

impl BitPack for (U7, u16)

type Packed = U23

fn pack(self) -> <(U7, u16) as BitPack>::Packed

fn unpack(packed: <(U7, u16) as BitPack>::Packed) -> (U7, u16)

impl BitPack for (U25, U12)

type Packed = U37

fn pack(self) -> <(U25, U12) as BitPack>::Packed

fn unpack(packed: <(U25, U12) as BitPack>::Packed) -> (U25, U12)

impl BitPack for (U7, U55)

type Packed = U62

fn pack(self) -> <(U7, U55) as BitPack>::Packed

fn unpack(packed: <(U7, U55) as BitPack>::Packed) -> (U7, U55)

impl BitPack for (U15, U11)

type Packed = U26

fn pack(self) -> <(U15, U11) as BitPack>::Packed

fn unpack(packed: <(U15, U11) as BitPack>::Packed) -> (U15, U11)

impl BitPack for (U29, U5)

type Packed = U34

fn pack(self) -> <(U29, U5) as BitPack>::Packed

fn unpack(packed: <(U29, U5) as BitPack>::Packed) -> (U29, U5)

impl BitPack for (U23, U20)

type Packed = U43

fn pack(self) -> <(U23, U20) as BitPack>::Packed

fn unpack(packed: <(U23, U20) as BitPack>::Packed) -> (U23, U20)

impl BitPack for (U41, U3)

type Packed = U44

fn pack(self) -> <(U41, U3) as BitPack>::Packed

fn unpack(packed: <(U41, U3) as BitPack>::Packed) -> (U41, U3)

impl BitPack for (U41, U18)

type Packed = U59

fn pack(self) -> <(U41, U18) as BitPack>::Packed

fn unpack(packed: <(U41, U18) as BitPack>::Packed) -> (U41, U18)

impl BitPack for (U28, U31)

type Packed = U59

fn pack(self) -> <(U28, U31) as BitPack>::Packed

fn unpack(packed: <(U28, U31) as BitPack>::Packed) -> (U28, U31)

impl BitPack for (U22, u16)

type Packed = U38

fn pack(self) -> <(U22, u16) as BitPack>::Packed

fn unpack(packed: <(U22, u16) as BitPack>::Packed) -> (U22, u16)

impl BitPack for (U18, u32)

type Packed = U50

fn pack(self) -> <(U18, u32) as BitPack>::Packed

fn unpack(packed: <(U18, u32) as BitPack>::Packed) -> (U18, u32)

impl BitPack for (U37, U14)

type Packed = U51

fn pack(self) -> <(U37, U14) as BitPack>::Packed

fn unpack(packed: <(U37, U14) as BitPack>::Packed) -> (U37, U14)

impl BitPack for (U54, U2)

type Packed = U56

fn pack(self) -> <(U54, U2) as BitPack>::Packed

fn unpack(packed: <(U54, U2) as BitPack>::Packed) -> (U54, U2)

impl BitPack for (U40, U17)

type Packed = U57

fn pack(self) -> <(U40, U17) as BitPack>::Packed

fn unpack(packed: <(U40, U17) as BitPack>::Packed) -> (U40, U17)

impl BitPack for (U41, u16)

type Packed = U57

fn pack(self) -> <(U41, u16) as BitPack>::Packed

fn unpack(packed: <(U41, u16) as BitPack>::Packed) -> (U41, u16)

impl BitPack for (U43, U4)

type Packed = U47

fn pack(self) -> <(U43, U4) as BitPack>::Packed

fn unpack(packed: <(U43, U4) as BitPack>::Packed) -> (U43, U4)

impl BitPack for (U33, U24)

type Packed = U57

fn pack(self) -> <(U33, U24) as BitPack>::Packed

fn unpack(packed: <(U33, U24) as BitPack>::Packed) -> (U33, U24)

impl BitPack for (U1, U39)

type Packed = U40

fn pack(self) -> <(U1, U39) as BitPack>::Packed

fn unpack(packed: <(U1, U39) as BitPack>::Packed) -> (U1, U39)

impl<T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T17, <(T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T17, <(T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U35, U2)

type Packed = U37

fn pack(self) -> <(U35, U2) as BitPack>::Packed

fn unpack(packed: <(U35, U2) as BitPack>::Packed) -> (U35, U2)

impl BitPack for (U11, U41)

type Packed = U52

fn pack(self) -> <(U11, U41) as BitPack>::Packed

fn unpack(packed: <(U11, U41) as BitPack>::Packed) -> (U11, U41)

impl BitPack for (U35, U28)

type Packed = U63

fn pack(self) -> <(U35, U28) as BitPack>::Packed

fn unpack(packed: <(U35, U28) as BitPack>::Packed) -> (U35, U28)

impl BitPack for (u8, U49)

type Packed = U57

fn pack(self) -> <(u8, U49) as BitPack>::Packed

fn unpack(packed: <(u8, U49) as BitPack>::Packed) -> (u8, U49)

impl BitPack for (U29, U18)

type Packed = U47

fn pack(self) -> <(U29, U18) as BitPack>::Packed

fn unpack(packed: <(U29, U18) as BitPack>::Packed) -> (U29, U18)

impl BitPack for (U28, U12)

type Packed = U40

fn pack(self) -> <(U28, U12) as BitPack>::Packed

fn unpack(packed: <(U28, U12) as BitPack>::Packed) -> (U28, U12)

impl BitPack for (U4, U6)

type Packed = U10

fn pack(self) -> <(U4, U6) as BitPack>::Packed

fn unpack(packed: <(U4, U6) as BitPack>::Packed) -> (U4, U6)

impl BitPack for (U2, U58)

type Packed = U60

fn pack(self) -> <(U2, U58) as BitPack>::Packed

fn unpack(packed: <(U2, U58) as BitPack>::Packed) -> (U2, U58)

impl BitPack for (U19, u8)

type Packed = U27

fn pack(self) -> <(U19, u8) as BitPack>::Packed

fn unpack(packed: <(U19, u8) as BitPack>::Packed) -> (U19, u8)

impl BitPack for (U35, U10)

type Packed = U45

fn pack(self) -> <(U35, U10) as BitPack>::Packed

fn unpack(packed: <(U35, U10) as BitPack>::Packed) -> (U35, U10)

impl BitPack for (u8, U14)

type Packed = U22

fn pack(self) -> <(u8, U14) as BitPack>::Packed

fn unpack(packed: <(u8, U14) as BitPack>::Packed) -> (u8, U14)

impl BitPack for (U19, U25)

type Packed = U44

fn pack(self) -> <(U19, U25) as BitPack>::Packed

fn unpack(packed: <(U19, U25) as BitPack>::Packed) -> (U19, U25)

impl BitPack for (U27, U34)

type Packed = U61

fn pack(self) -> <(U27, U34) as BitPack>::Packed

fn unpack(packed: <(U27, U34) as BitPack>::Packed) -> (U27, U34)

impl BitPack for (U9, U19)

type Packed = U28

fn pack(self) -> <(U9, U19) as BitPack>::Packed

fn unpack(packed: <(U9, U19) as BitPack>::Packed) -> (U9, U19)

impl BitPack for (U12, u8)

type Packed = U20

fn pack(self) -> <(U12, u8) as BitPack>::Packed

fn unpack(packed: <(U12, u8) as BitPack>::Packed) -> (U12, u8)

impl BitPack for (U9, U54)

type Packed = U63

fn pack(self) -> <(U9, U54) as BitPack>::Packed

fn unpack(packed: <(U9, U54) as BitPack>::Packed) -> (U9, U54)

impl BitPack for (U38, U11)

type Packed = U49

fn pack(self) -> <(U38, U11) as BitPack>::Packed

fn unpack(packed: <(U38, U11) as BitPack>::Packed) -> (U38, U11)

impl BitPack for (U37, U27)

type Packed = u64

fn pack(self) -> <(U37, U27) as BitPack>::Packed

fn unpack(packed: <(U37, U27) as BitPack>::Packed) -> (U37, U27)

impl BitPack for (U26, U33)

type Packed = U59

fn pack(self) -> <(U26, U33) as BitPack>::Packed

fn unpack(packed: <(U26, U33) as BitPack>::Packed) -> (U26, U33)

impl BitPack for (U18, U24)

type Packed = U42

fn pack(self) -> <(U18, U24) as BitPack>::Packed

fn unpack(packed: <(U18, U24) as BitPack>::Packed) -> (U18, U24)

impl BitPack for (U41, U12)

type Packed = U53

fn pack(self) -> <(U41, U12) as BitPack>::Packed

fn unpack(packed: <(U41, U12) as BitPack>::Packed) -> (U41, U12)

impl BitPack for (U3, U58)

type Packed = U61

fn pack(self) -> <(U3, U58) as BitPack>::Packed

fn unpack(packed: <(U3, U58) as BitPack>::Packed) -> (U3, U58)

impl BitPack for (U14, U29)

type Packed = U43

fn pack(self) -> <(U14, U29) as BitPack>::Packed

fn unpack(packed: <(U14, U29) as BitPack>::Packed) -> (U14, U29)

impl BitPack for (U37, U9)

type Packed = U46

fn pack(self) -> <(U37, U9) as BitPack>::Packed

fn unpack(packed: <(U37, U9) as BitPack>::Packed) -> (U37, U9)

impl BitPack for (u8, U36)

type Packed = U44

fn pack(self) -> <(u8, U36) as BitPack>::Packed

fn unpack(packed: <(u8, U36) as BitPack>::Packed) -> (u8, U36)

impl BitPack for (U1, U37)

type Packed = U38

fn pack(self) -> <(U1, U37) as BitPack>::Packed

fn unpack(packed: <(U1, U37) as BitPack>::Packed) -> (U1, U37)

impl BitPack for (U18, U30)

type Packed = U48

fn pack(self) -> <(U18, U30) as BitPack>::Packed

fn unpack(packed: <(U18, U30) as BitPack>::Packed) -> (U18, U30)

impl BitPack for (U11, U14)

type Packed = U25

fn pack(self) -> <(U11, U14) as BitPack>::Packed

fn unpack(packed: <(U11, U14) as BitPack>::Packed) -> (U11, U14)

impl BitPack for (U1, U50)

type Packed = U51

fn pack(self) -> <(U1, U50) as BitPack>::Packed

fn unpack(packed: <(U1, U50) as BitPack>::Packed) -> (U1, U50)

impl BitPack for (U35, U14)

type Packed = U49

fn pack(self) -> <(U35, U14) as BitPack>::Packed

fn unpack(packed: <(U35, U14) as BitPack>::Packed) -> (U35, U14)

impl BitPack for (u32, U12)

type Packed = U44

fn pack(self) -> <(u32, U12) as BitPack>::Packed

fn unpack(packed: <(u32, U12) as BitPack>::Packed) -> (u32, U12)

impl BitPack for (u16, U47)

type Packed = U63

fn pack(self) -> <(u16, U47) as BitPack>::Packed

fn unpack(packed: <(u16, U47) as BitPack>::Packed) -> (u16, U47)

impl BitPack for (U17, U43)

type Packed = U60

fn pack(self) -> <(U17, U43) as BitPack>::Packed

fn unpack(packed: <(U17, U43) as BitPack>::Packed) -> (U17, U43)

impl BitPack for (U10, U51)

type Packed = U61

fn pack(self) -> <(U10, U51) as BitPack>::Packed

fn unpack(packed: <(U10, U51) as BitPack>::Packed) -> (U10, U51)

impl BitPack for (U21, U29)

type Packed = U50

fn pack(self) -> <(U21, U29) as BitPack>::Packed

fn unpack(packed: <(U21, U29) as BitPack>::Packed) -> (U21, U29)

impl BitPack for (U22, U22)

type Packed = U44

fn pack(self) -> <(U22, U22) as BitPack>::Packed

fn unpack(packed: <(U22, U22) as BitPack>::Packed) -> (U22, U22)

impl BitPack for (U12, U48)

type Packed = U60

fn pack(self) -> <(U12, U48) as BitPack>::Packed

fn unpack(packed: <(U12, U48) as BitPack>::Packed) -> (U12, U48)

impl BitPack for (U15, U28)

type Packed = U43

fn pack(self) -> <(U15, U28) as BitPack>::Packed

fn unpack(packed: <(U15, U28) as BitPack>::Packed) -> (U15, U28)

impl<T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T25, <(T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T25, <(T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U4, U41)

type Packed = U45

fn pack(self) -> <(U4, U41) as BitPack>::Packed

fn unpack(packed: <(U4, U41) as BitPack>::Packed) -> (U4, U41)

impl BitPack for (U29, U22)

type Packed = U51

fn pack(self) -> <(U29, U22) as BitPack>::Packed

fn unpack(packed: <(U29, U22) as BitPack>::Packed) -> (U29, U22)

impl BitPack for (U25, U5)

type Packed = U30

fn pack(self) -> <(U25, U5) as BitPack>::Packed

fn unpack(packed: <(U25, U5) as BitPack>::Packed) -> (U25, U5)

impl BitPack for (U24, U13)

type Packed = U37

fn pack(self) -> <(U24, U13) as BitPack>::Packed

fn unpack(packed: <(U24, U13) as BitPack>::Packed) -> (U24, U13)

impl BitPack for (U18, U42)

type Packed = U60

fn pack(self) -> <(U18, U42) as BitPack>::Packed

fn unpack(packed: <(U18, U42) as BitPack>::Packed) -> (U18, U42)

impl BitPack for (U30, u16)

type Packed = U46

fn pack(self) -> <(U30, u16) as BitPack>::Packed

fn unpack(packed: <(U30, u16) as BitPack>::Packed) -> (U30, u16)

impl BitPack for (U19, U11)

type Packed = U30

fn pack(self) -> <(U19, U11) as BitPack>::Packed

fn unpack(packed: <(U19, U11) as BitPack>::Packed) -> (U19, U11)

impl BitPack for (U48, U11)

type Packed = U59

fn pack(self) -> <(U48, U11) as BitPack>::Packed

fn unpack(packed: <(U48, U11) as BitPack>::Packed) -> (U48, U11)

impl BitPack for (u16, U27)

type Packed = U43

fn pack(self) -> <(u16, U27) as BitPack>::Packed

fn unpack(packed: <(u16, U27) as BitPack>::Packed) -> (u16, U27)

impl BitPack for (U10, U14)

type Packed = U24

fn pack(self) -> <(U10, U14) as BitPack>::Packed

fn unpack(packed: <(U10, U14) as BitPack>::Packed) -> (U10, U14)

impl BitPack for (U23, U37)

type Packed = U60

fn pack(self) -> <(U23, U37) as BitPack>::Packed

fn unpack(packed: <(U23, U37) as BitPack>::Packed) -> (U23, U37)

impl BitPack for (U27, u8)

type Packed = U35

fn pack(self) -> <(U27, u8) as BitPack>::Packed

fn unpack(packed: <(U27, u8) as BitPack>::Packed) -> (U27, u8)

impl BitPack for (U52, U4)

type Packed = U56

fn pack(self) -> <(U52, U4) as BitPack>::Packed

fn unpack(packed: <(U52, U4) as BitPack>::Packed) -> (U52, U4)

impl<T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T5, <(T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T5, <(T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U29, U29)

type Packed = U58

fn pack(self) -> <(U29, U29) as BitPack>::Packed

fn unpack(packed: <(U29, U29) as BitPack>::Packed) -> (U29, U29)

impl BitPack for (U10, u16)

type Packed = U26

fn pack(self) -> <(U10, u16) as BitPack>::Packed

fn unpack(packed: <(U10, u16) as BitPack>::Packed) -> (U10, u16)

impl BitPack for (U2, U13)

type Packed = U15

fn pack(self) -> <(U2, U13) as BitPack>::Packed

fn unpack(packed: <(U2, U13) as BitPack>::Packed) -> (U2, U13)

impl BitPack for (U26, U11)

type Packed = U37

fn pack(self) -> <(U26, U11) as BitPack>::Packed

fn unpack(packed: <(U26, U11) as BitPack>::Packed) -> (U26, U11)

impl BitPack for (U50, U1)

type Packed = U51

fn pack(self) -> <(U50, U1) as BitPack>::Packed

fn unpack(packed: <(U50, U1) as BitPack>::Packed) -> (U50, U1)

impl BitPack for (U44, U3)

type Packed = U47

fn pack(self) -> <(U44, U3) as BitPack>::Packed

fn unpack(packed: <(U44, U3) as BitPack>::Packed) -> (U44, U3)

impl BitPack for (U36, U28)

type Packed = u64

fn pack(self) -> <(U36, U28) as BitPack>::Packed

fn unpack(packed: <(U36, U28) as BitPack>::Packed) -> (U36, U28)

impl BitPack for (U18, U46)

type Packed = u64

fn pack(self) -> <(U18, U46) as BitPack>::Packed

fn unpack(packed: <(U18, U46) as BitPack>::Packed) -> (U18, U46)

impl BitPack for (U46, U4)

type Packed = U50

fn pack(self) -> <(U46, U4) as BitPack>::Packed

fn unpack(packed: <(U46, U4) as BitPack>::Packed) -> (U46, U4)

impl BitPack for (U6, U49)

type Packed = U55

fn pack(self) -> <(U6, U49) as BitPack>::Packed

fn unpack(packed: <(U6, U49) as BitPack>::Packed) -> (U6, U49)

impl BitPack for (u32, U23)

type Packed = U55

fn pack(self) -> <(u32, U23) as BitPack>::Packed

fn unpack(packed: <(u32, U23) as BitPack>::Packed) -> (u32, U23)

impl BitPack for (u8, U3)

type Packed = U11

fn pack(self) -> <(u8, U3) as BitPack>::Packed

fn unpack(packed: <(u8, U3) as BitPack>::Packed) -> (u8, U3)

impl BitPack for (U38, U10)

type Packed = U48

fn pack(self) -> <(U38, U10) as BitPack>::Packed

fn unpack(packed: <(U38, U10) as BitPack>::Packed) -> (U38, U10)

impl BitPack for (U46, U14)

type Packed = U60

fn pack(self) -> <(U46, U14) as BitPack>::Packed

fn unpack(packed: <(U46, U14) as BitPack>::Packed) -> (U46, U14)

impl BitPack for (U20, u32)

type Packed = U52

fn pack(self) -> <(U20, u32) as BitPack>::Packed

fn unpack(packed: <(U20, u32) as BitPack>::Packed) -> (U20, u32)

impl BitPack for (U9, U10)

type Packed = U19

fn pack(self) -> <(U9, U10) as BitPack>::Packed

fn unpack(packed: <(U9, U10) as BitPack>::Packed) -> (U9, U10)

impl BitPack for (u8, U55)

type Packed = U63

fn pack(self) -> <(u8, U55) as BitPack>::Packed

fn unpack(packed: <(u8, U55) as BitPack>::Packed) -> (u8, U55)

impl BitPack for (U30, U1)

type Packed = U31

fn pack(self) -> <(U30, U1) as BitPack>::Packed

fn unpack(packed: <(U30, U1) as BitPack>::Packed) -> (U30, U1)

impl BitPack for (U55, U4)

type Packed = U59

fn pack(self) -> <(U55, U4) as BitPack>::Packed

fn unpack(packed: <(U55, U4) as BitPack>::Packed) -> (U55, U4)

impl<T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T27, <(T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T27, <(T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U21, U22)

type Packed = U43

fn pack(self) -> <(U21, U22) as BitPack>::Packed

fn unpack(packed: <(U21, U22) as BitPack>::Packed) -> (U21, U22)

impl BitPack for (U22, U13)

type Packed = U35

fn pack(self) -> <(U22, U13) as BitPack>::Packed

fn unpack(packed: <(U22, U13) as BitPack>::Packed) -> (U22, U13)

impl BitPack for (U5, U27)

type Packed = u32

fn pack(self) -> <(U5, U27) as BitPack>::Packed

fn unpack(packed: <(U5, U27) as BitPack>::Packed) -> (U5, U27)

impl BitPack for (U6, U4)

type Packed = U10

fn pack(self) -> <(U6, U4) as BitPack>::Packed

fn unpack(packed: <(U6, U4) as BitPack>::Packed) -> (U6, U4)

impl BitPack for (U20, U2)

type Packed = U22

fn pack(self) -> <(U20, U2) as BitPack>::Packed

fn unpack(packed: <(U20, U2) as BitPack>::Packed) -> (U20, U2)

impl BitPack for (U26, U14)

type Packed = U40

fn pack(self) -> <(U26, U14) as BitPack>::Packed

fn unpack(packed: <(U26, U14) as BitPack>::Packed) -> (U26, U14)

impl BitPack for (U34, U19)

type Packed = U53

fn pack(self) -> <(U34, U19) as BitPack>::Packed

fn unpack(packed: <(U34, U19) as BitPack>::Packed) -> (U34, U19)

impl BitPack for (U28, U24)

type Packed = U52

fn pack(self) -> <(U28, U24) as BitPack>::Packed

fn unpack(packed: <(U28, U24) as BitPack>::Packed) -> (U28, U24)

impl BitPack for (U41, u8)

type Packed = U49

fn pack(self) -> <(U41, u8) as BitPack>::Packed

fn unpack(packed: <(U41, u8) as BitPack>::Packed) -> (U41, u8)

impl BitPack for (U26, U23)

type Packed = U49

fn pack(self) -> <(U26, U23) as BitPack>::Packed

fn unpack(packed: <(U26, U23) as BitPack>::Packed) -> (U26, U23)

impl BitPack for (U4, u16)

type Packed = U20

fn pack(self) -> <(U4, u16) as BitPack>::Packed

fn unpack(packed: <(U4, u16) as BitPack>::Packed) -> (U4, u16)

impl BitPack for (U21, U35)

type Packed = U56

fn pack(self) -> <(U21, U35) as BitPack>::Packed

fn unpack(packed: <(U21, U35) as BitPack>::Packed) -> (U21, U35)

impl BitPack for (U43, U12)

type Packed = U55

fn pack(self) -> <(U43, U12) as BitPack>::Packed

fn unpack(packed: <(U43, U12) as BitPack>::Packed) -> (U43, U12)

impl BitPack for (U5, u32)

type Packed = U37

fn pack(self) -> <(U5, u32) as BitPack>::Packed

fn unpack(packed: <(U5, u32) as BitPack>::Packed) -> (U5, u32)

impl BitPack for (U36, U18)

type Packed = U54

fn pack(self) -> <(U36, U18) as BitPack>::Packed

fn unpack(packed: <(U36, U18) as BitPack>::Packed) -> (U36, U18)

impl BitPack for (U3, U27)

type Packed = U30

fn pack(self) -> <(U3, U27) as BitPack>::Packed

fn unpack(packed: <(U3, U27) as BitPack>::Packed) -> (U3, U27)

impl BitPack for (U53, U10)

type Packed = U63

fn pack(self) -> <(U53, U10) as BitPack>::Packed

fn unpack(packed: <(U53, U10) as BitPack>::Packed) -> (U53, U10)

impl BitPack for (U9, U52)

type Packed = U61

fn pack(self) -> <(U9, U52) as BitPack>::Packed

fn unpack(packed: <(U9, U52) as BitPack>::Packed) -> (U9, U52)

impl BitPack for (U47, u8)

type Packed = U55

fn pack(self) -> <(U47, u8) as BitPack>::Packed

fn unpack(packed: <(U47, u8) as BitPack>::Packed) -> (U47, u8)

impl BitPack for (U48, u16)

type Packed = u64

fn pack(self) -> <(U48, u16) as BitPack>::Packed

fn unpack(packed: <(U48, u16) as BitPack>::Packed) -> (U48, u16)

impl BitPack for (U15, U18)

type Packed = U33

fn pack(self) -> <(U15, U18) as BitPack>::Packed

fn unpack(packed: <(U15, U18) as BitPack>::Packed) -> (U15, U18)

impl BitPack for (U3, U56)

type Packed = U59

fn pack(self) -> <(U3, U56) as BitPack>::Packed

fn unpack(packed: <(U3, U56) as BitPack>::Packed) -> (U3, U56)

impl BitPack for (U2, U11)

type Packed = U13

fn pack(self) -> <(U2, U11) as BitPack>::Packed

fn unpack(packed: <(U2, U11) as BitPack>::Packed) -> (U2, U11)

impl BitPack for (U46, U11)

type Packed = U57

fn pack(self) -> <(U46, U11) as BitPack>::Packed

fn unpack(packed: <(U46, U11) as BitPack>::Packed) -> (U46, U11)

impl BitPack for (U48, U9)

type Packed = U57

fn pack(self) -> <(U48, U9) as BitPack>::Packed

fn unpack(packed: <(U48, U9) as BitPack>::Packed) -> (U48, U9)

impl BitPack for (U3, U13)

type Packed = u16

fn pack(self) -> <(U3, U13) as BitPack>::Packed

fn unpack(packed: <(U3, U13) as BitPack>::Packed) -> (U3, U13)

impl BitPack for (U21, U17)

type Packed = U38

fn pack(self) -> <(U21, U17) as BitPack>::Packed

fn unpack(packed: <(U21, U17) as BitPack>::Packed) -> (U21, U17)

impl BitPack for (U24, u16)

type Packed = U40

fn pack(self) -> <(U24, u16) as BitPack>::Packed

fn unpack(packed: <(U24, u16) as BitPack>::Packed) -> (U24, u16)

impl BitPack for (U2, U56)

type Packed = U58

fn pack(self) -> <(U2, U56) as BitPack>::Packed

fn unpack(packed: <(U2, U56) as BitPack>::Packed) -> (U2, U56)

impl BitPack for (U34, u8)

type Packed = U42

fn pack(self) -> <(U34, u8) as BitPack>::Packed

fn unpack(packed: <(U34, u8) as BitPack>::Packed) -> (U34, u8)

impl BitPack for (U36, U11)

type Packed = U47

fn pack(self) -> <(U36, U11) as BitPack>::Packed

fn unpack(packed: <(U36, U11) as BitPack>::Packed) -> (U36, U11)

impl BitPack for (U4, U37)

type Packed = U41

fn pack(self) -> <(U4, U37) as BitPack>::Packed

fn unpack(packed: <(U4, U37) as BitPack>::Packed) -> (U4, U37)

impl BitPack for (U26, U25)

type Packed = U51

fn pack(self) -> <(U26, U25) as BitPack>::Packed

fn unpack(packed: <(U26, U25) as BitPack>::Packed) -> (U26, U25)

impl BitPack for (U14, u32)

type Packed = U46

fn pack(self) -> <(U14, u32) as BitPack>::Packed

fn unpack(packed: <(U14, u32) as BitPack>::Packed) -> (U14, u32)

impl BitPack for (U14, U10)

type Packed = U24

fn pack(self) -> <(U14, U10) as BitPack>::Packed

fn unpack(packed: <(U14, U10) as BitPack>::Packed) -> (U14, U10)

impl BitPack for (U12, U49)

type Packed = U61

fn pack(self) -> <(U12, U49) as BitPack>::Packed

fn unpack(packed: <(U12, U49) as BitPack>::Packed) -> (U12, U49)

impl BitPack for (U51, U12)

type Packed = U63

fn pack(self) -> <(U51, U12) as BitPack>::Packed

fn unpack(packed: <(U51, U12) as BitPack>::Packed) -> (U51, U12)

impl BitPack for (U14, U24)

type Packed = U38

fn pack(self) -> <(U14, U24) as BitPack>::Packed

fn unpack(packed: <(U14, U24) as BitPack>::Packed) -> (U14, U24)

impl BitPack for (u8, U53)

type Packed = U61

fn pack(self) -> <(u8, U53) as BitPack>::Packed

fn unpack(packed: <(u8, U53) as BitPack>::Packed) -> (u8, U53)

impl BitPack for (U14, U17)

type Packed = U31

fn pack(self) -> <(U14, U17) as BitPack>::Packed

fn unpack(packed: <(U14, U17) as BitPack>::Packed) -> (U14, U17)

impl BitPack for (u16, U39)

type Packed = U55

fn pack(self) -> <(u16, U39) as BitPack>::Packed

fn unpack(packed: <(u16, U39) as BitPack>::Packed) -> (u16, U39)

impl BitPack for (u16, U24)

type Packed = U40

fn pack(self) -> <(u16, U24) as BitPack>::Packed

fn unpack(packed: <(u16, U24) as BitPack>::Packed) -> (u16, U24)

impl BitPack for (U4, U52)

type Packed = U56

fn pack(self) -> <(U4, U52) as BitPack>::Packed

fn unpack(packed: <(U4, U52) as BitPack>::Packed) -> (U4, U52)

impl BitPack for (U27, U21)

type Packed = U48

fn pack(self) -> <(U27, U21) as BitPack>::Packed

fn unpack(packed: <(U27, U21) as BitPack>::Packed) -> (U27, U21)

impl BitPack for (U9, U25)

type Packed = U34

fn pack(self) -> <(U9, U25) as BitPack>::Packed

fn unpack(packed: <(U9, U25) as BitPack>::Packed) -> (U9, U25)

impl BitPack for (u8, U47)

type Packed = U55

fn pack(self) -> <(u8, U47) as BitPack>::Packed

fn unpack(packed: <(u8, U47) as BitPack>::Packed) -> (u8, U47)

impl BitPack for (U13, U38)

type Packed = U51

fn pack(self) -> <(U13, U38) as BitPack>::Packed

fn unpack(packed: <(U13, U38) as BitPack>::Packed) -> (U13, U38)

impl BitPack for (U9, U48)

type Packed = U57

fn pack(self) -> <(U9, U48) as BitPack>::Packed

fn unpack(packed: <(U9, U48) as BitPack>::Packed) -> (U9, U48)

impl BitPack for (U1, U11)

type Packed = U12

fn pack(self) -> <(U1, U11) as BitPack>::Packed

fn unpack(packed: <(U1, U11) as BitPack>::Packed) -> (U1, U11)

impl BitPack for (U13, U50)

type Packed = U63

fn pack(self) -> <(U13, U50) as BitPack>::Packed

fn unpack(packed: <(U13, U50) as BitPack>::Packed) -> (U13, U50)

impl BitPack for (U17, U13)

type Packed = U30

fn pack(self) -> <(U17, U13) as BitPack>::Packed

fn unpack(packed: <(U17, U13) as BitPack>::Packed) -> (U17, U13)

impl BitPack for (U2, U44)

type Packed = U46

fn pack(self) -> <(U2, U44) as BitPack>::Packed

fn unpack(packed: <(U2, U44) as BitPack>::Packed) -> (U2, U44)

impl BitPack for (U9, U24)

type Packed = U33

fn pack(self) -> <(U9, U24) as BitPack>::Packed

fn unpack(packed: <(U9, U24) as BitPack>::Packed) -> (U9, U24)

impl BitPack for (U1, U17)

type Packed = U18

fn pack(self) -> <(U1, U17) as BitPack>::Packed

fn unpack(packed: <(U1, U17) as BitPack>::Packed) -> (U1, U17)

impl BitPack for (U6, U57)

type Packed = U63

fn pack(self) -> <(U6, U57) as BitPack>::Packed

fn unpack(packed: <(U6, U57) as BitPack>::Packed) -> (U6, U57)

impl BitPack for (U18, U45)

type Packed = U63

fn pack(self) -> <(U18, U45) as BitPack>::Packed

fn unpack(packed: <(U18, U45) as BitPack>::Packed) -> (U18, U45)

impl BitPack for (U3, U44)

type Packed = U47

fn pack(self) -> <(U3, U44) as BitPack>::Packed

fn unpack(packed: <(U3, U44) as BitPack>::Packed) -> (U3, U44)

impl BitPack for (U7, U12)

type Packed = U19

fn pack(self) -> <(U7, U12) as BitPack>::Packed

fn unpack(packed: <(U7, U12) as BitPack>::Packed) -> (U7, U12)

impl BitPack for (U19, U19)

type Packed = U38

fn pack(self) -> <(U19, U19) as BitPack>::Packed

fn unpack(packed: <(U19, U19) as BitPack>::Packed) -> (U19, U19)

impl BitPack for (U40, U19)

type Packed = U59

fn pack(self) -> <(U40, U19) as BitPack>::Packed

fn unpack(packed: <(U40, U19) as BitPack>::Packed) -> (U40, U19)

impl BitPack for (U51, U2)

type Packed = U53

fn pack(self) -> <(U51, U2) as BitPack>::Packed

fn unpack(packed: <(U51, U2) as BitPack>::Packed) -> (U51, U2)

impl BitPack for (u8, U35)

type Packed = U43

fn pack(self) -> <(u8, U35) as BitPack>::Packed

fn unpack(packed: <(u8, U35) as BitPack>::Packed) -> (u8, U35)

impl BitPack for (U26, U6)

type Packed = u32

fn pack(self) -> <(U26, U6) as BitPack>::Packed

fn unpack(packed: <(U26, U6) as BitPack>::Packed) -> (U26, U6)

impl BitPack for (u16, U18)

type Packed = U34

fn pack(self) -> <(u16, U18) as BitPack>::Packed

fn unpack(packed: <(u16, U18) as BitPack>::Packed) -> (u16, U18)

impl BitPack for (U33, U25)

type Packed = U58

fn pack(self) -> <(U33, U25) as BitPack>::Packed

fn unpack(packed: <(U33, U25) as BitPack>::Packed) -> (U33, U25)

impl BitPack for (u8, U42)

type Packed = U50

fn pack(self) -> <(u8, U42) as BitPack>::Packed

fn unpack(packed: <(u8, U42) as BitPack>::Packed) -> (u8, U42)

impl BitPack for (U19, U43)

type Packed = U62

fn pack(self) -> <(U19, U43) as BitPack>::Packed

fn unpack(packed: <(U19, U43) as BitPack>::Packed) -> (U19, U43)

impl BitPack for (U22, U17)

type Packed = U39

fn pack(self) -> <(U22, U17) as BitPack>::Packed

fn unpack(packed: <(U22, U17) as BitPack>::Packed) -> (U22, U17)

impl BitPack for (U26, U30)

type Packed = U56

fn pack(self) -> <(U26, U30) as BitPack>::Packed

fn unpack(packed: <(U26, U30) as BitPack>::Packed) -> (U26, U30)

impl BitPack for (U26, U29)

type Packed = U55

fn pack(self) -> <(U26, U29) as BitPack>::Packed

fn unpack(packed: <(U26, U29) as BitPack>::Packed) -> (U26, U29)

impl BitPack for (U6, U20)

type Packed = U26

fn pack(self) -> <(U6, U20) as BitPack>::Packed

fn unpack(packed: <(U6, U20) as BitPack>::Packed) -> (U6, U20)

impl BitPack for (U23, u8)

type Packed = U31

fn pack(self) -> <(U23, u8) as BitPack>::Packed

fn unpack(packed: <(U23, u8) as BitPack>::Packed) -> (U23, u8)

impl BitPack for (U22, U2)

type Packed = U24

fn pack(self) -> <(U22, U2) as BitPack>::Packed

fn unpack(packed: <(U22, U2) as BitPack>::Packed) -> (U22, U2)

impl BitPack for (U29, U26)

type Packed = U55

fn pack(self) -> <(U29, U26) as BitPack>::Packed

fn unpack(packed: <(U29, U26) as BitPack>::Packed) -> (U29, U26)

impl BitPack for (U52, U3)

type Packed = U55

fn pack(self) -> <(U52, U3) as BitPack>::Packed

fn unpack(packed: <(U52, U3) as BitPack>::Packed) -> (U52, U3)

impl BitPack for (U51, U5)

type Packed = U56

fn pack(self) -> <(U51, U5) as BitPack>::Packed

fn unpack(packed: <(U51, U5) as BitPack>::Packed) -> (U51, U5)

impl BitPack for (U30, U33)

type Packed = U63

fn pack(self) -> <(U30, U33) as BitPack>::Packed

fn unpack(packed: <(U30, U33) as BitPack>::Packed) -> (U30, U33)

impl BitPack for (U13, U10)

type Packed = U23

fn pack(self) -> <(U13, U10) as BitPack>::Packed

fn unpack(packed: <(U13, U10) as BitPack>::Packed) -> (U13, U10)

impl BitPack for (U34, U27)

type Packed = U61

fn pack(self) -> <(U34, U27) as BitPack>::Packed

fn unpack(packed: <(U34, U27) as BitPack>::Packed) -> (U34, U27)

impl BitPack for (u16, U14)

type Packed = U30

fn pack(self) -> <(u16, U14) as BitPack>::Packed

fn unpack(packed: <(u16, U14) as BitPack>::Packed) -> (u16, U14)

impl BitPack for (U10, U21)

type Packed = U31

fn pack(self) -> <(U10, U21) as BitPack>::Packed

fn unpack(packed: <(U10, U21) as BitPack>::Packed) -> (U10, U21)

impl BitPack for (U3, U23)

type Packed = U26

fn pack(self) -> <(U3, U23) as BitPack>::Packed

fn unpack(packed: <(U3, U23) as BitPack>::Packed) -> (U3, U23)

impl BitPack for (U17, U4)

type Packed = U21

fn pack(self) -> <(U17, U4) as BitPack>::Packed

fn unpack(packed: <(U17, U4) as BitPack>::Packed) -> (U17, U4)

impl BitPack for (U1, U22)

type Packed = U23

fn pack(self) -> <(U1, U22) as BitPack>::Packed

fn unpack(packed: <(U1, U22) as BitPack>::Packed) -> (U1, U22)

impl BitPack for (U12, U41)

type Packed = U53

fn pack(self) -> <(U12, U41) as BitPack>::Packed

fn unpack(packed: <(U12, U41) as BitPack>::Packed) -> (U12, U41)

impl BitPack for (U29, U35)

type Packed = u64

fn pack(self) -> <(U29, U35) as BitPack>::Packed

fn unpack(packed: <(U29, U35) as BitPack>::Packed) -> (U29, U35)

impl BitPack for (U30, U24)

type Packed = U54

fn pack(self) -> <(U30, U24) as BitPack>::Packed

fn unpack(packed: <(U30, U24) as BitPack>::Packed) -> (U30, U24)

impl BitPack for (U6, U54)

type Packed = U60

fn pack(self) -> <(U6, U54) as BitPack>::Packed

fn unpack(packed: <(U6, U54) as BitPack>::Packed) -> (U6, U54)

impl BitPack for (U39, U3)

type Packed = U42

fn pack(self) -> <(U39, U3) as BitPack>::Packed

fn unpack(packed: <(U39, U3) as BitPack>::Packed) -> (U39, U3)

impl BitPack for (U10, u32)

type Packed = U42

fn pack(self) -> <(U10, u32) as BitPack>::Packed

fn unpack(packed: <(U10, u32) as BitPack>::Packed) -> (U10, u32)

impl BitPack for (U18, U13)

type Packed = U31

fn pack(self) -> <(U18, U13) as BitPack>::Packed

fn unpack(packed: <(U18, U13) as BitPack>::Packed) -> (U18, U13)

impl<T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T49, <(T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T49, <(T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl<T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T37, <(T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T37, <(T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U3, U18)

type Packed = U21

fn pack(self) -> <(U3, U18) as BitPack>::Packed

fn unpack(packed: <(U3, U18) as BitPack>::Packed) -> (U3, U18)

impl BitPack for (U34, U10)

type Packed = U44

fn pack(self) -> <(U34, U10) as BitPack>::Packed

fn unpack(packed: <(U34, U10) as BitPack>::Packed) -> (U34, U10)

impl BitPack for (U53, U5)

type Packed = U58

fn pack(self) -> <(U53, U5) as BitPack>::Packed

fn unpack(packed: <(U53, U5) as BitPack>::Packed) -> (U53, U5)

impl BitPack for (U13, U41)

type Packed = U54

fn pack(self) -> <(U13, U41) as BitPack>::Packed

fn unpack(packed: <(U13, U41) as BitPack>::Packed) -> (U13, U41)

impl BitPack for (U4, U23)

type Packed = U27

fn pack(self) -> <(U4, U23) as BitPack>::Packed

fn unpack(packed: <(U4, U23) as BitPack>::Packed) -> (U4, U23)

impl BitPack for (U24, U31)

type Packed = U55

fn pack(self) -> <(U24, U31) as BitPack>::Packed

fn unpack(packed: <(U24, U31) as BitPack>::Packed) -> (U24, U31)

impl BitPack for (U9, U41)

type Packed = U50

fn pack(self) -> <(U9, U41) as BitPack>::Packed

fn unpack(packed: <(U9, U41) as BitPack>::Packed) -> (U9, U41)

impl BitPack for (U17, U6)

type Packed = U23

fn pack(self) -> <(U17, U6) as BitPack>::Packed

fn unpack(packed: <(U17, U6) as BitPack>::Packed) -> (U17, U6)

impl BitPack for (U17, U44)

type Packed = U61

fn pack(self) -> <(U17, U44) as BitPack>::Packed

fn unpack(packed: <(U17, U44) as BitPack>::Packed) -> (U17, U44)

impl BitPack for (U38, u8)

type Packed = U46

fn pack(self) -> <(U38, u8) as BitPack>::Packed

fn unpack(packed: <(U38, u8) as BitPack>::Packed) -> (U38, u8)

impl BitPack for (U23, U22)

type Packed = U45

fn pack(self) -> <(U23, U22) as BitPack>::Packed

fn unpack(packed: <(U23, U22) as BitPack>::Packed) -> (U23, U22)

impl BitPack for (U10, U41)

type Packed = U51

fn pack(self) -> <(U10, U41) as BitPack>::Packed

fn unpack(packed: <(U10, U41) as BitPack>::Packed) -> (U10, U41)

impl BitPack for (U24, U14)

type Packed = U38

fn pack(self) -> <(U24, U14) as BitPack>::Packed

fn unpack(packed: <(U24, U14) as BitPack>::Packed) -> (U24, U14)

impl BitPack for (u8, U4)

type Packed = U12

fn pack(self) -> <(u8, U4) as BitPack>::Packed

fn unpack(packed: <(u8, U4) as BitPack>::Packed) -> (u8, U4)

impl BitPack for (U27, U22)

type Packed = U49

fn pack(self) -> <(U27, U22) as BitPack>::Packed

fn unpack(packed: <(U27, U22) as BitPack>::Packed) -> (U27, U22)

impl BitPack for (U30, U28)

type Packed = U58

fn pack(self) -> <(U30, U28) as BitPack>::Packed

fn unpack(packed: <(U30, U28) as BitPack>::Packed) -> (U30, U28)

impl BitPack for (U6, U48)

type Packed = U54

fn pack(self) -> <(U6, U48) as BitPack>::Packed

fn unpack(packed: <(U6, U48) as BitPack>::Packed) -> (U6, U48)

impl BitPack for (U14, U21)

type Packed = U35

fn pack(self) -> <(U14, U21) as BitPack>::Packed

fn unpack(packed: <(U14, U21) as BitPack>::Packed) -> (U14, U21)

impl BitPack for (U40, U20)

type Packed = U60

fn pack(self) -> <(U40, U20) as BitPack>::Packed

fn unpack(packed: <(U40, U20) as BitPack>::Packed) -> (U40, U20)

impl BitPack for (U14, U30)

type Packed = U44

fn pack(self) -> <(U14, U30) as BitPack>::Packed

fn unpack(packed: <(U14, U30) as BitPack>::Packed) -> (U14, U30)

impl BitPack for (U18, U7)

type Packed = U25

fn pack(self) -> <(U18, U7) as BitPack>::Packed

fn unpack(packed: <(U18, U7) as BitPack>::Packed) -> (U18, U7)

impl BitPack for (U33, U9)

type Packed = U42

fn pack(self) -> <(U33, U9) as BitPack>::Packed

fn unpack(packed: <(U33, U9) as BitPack>::Packed) -> (U33, U9)

impl BitPack for (U1, U31)

type Packed = u32

fn pack(self) -> <(U1, U31) as BitPack>::Packed

fn unpack(packed: <(U1, U31) as BitPack>::Packed) -> (U1, U31)

impl BitPack for (u32, U26)

type Packed = U58

fn pack(self) -> <(u32, U26) as BitPack>::Packed

fn unpack(packed: <(u32, U26) as BitPack>::Packed) -> (u32, U26)

impl BitPack for (U15, U17)

type Packed = u32

fn pack(self) -> <(U15, U17) as BitPack>::Packed

fn unpack(packed: <(U15, U17) as BitPack>::Packed) -> (U15, U17)

impl BitPack for (U29, U2)

type Packed = U31

fn pack(self) -> <(U29, U2) as BitPack>::Packed

fn unpack(packed: <(U29, U2) as BitPack>::Packed) -> (U29, U2)

impl BitPack for (U7, U40)

type Packed = U47

fn pack(self) -> <(U7, U40) as BitPack>::Packed

fn unpack(packed: <(U7, U40) as BitPack>::Packed) -> (U7, U40)

impl BitPack for (U10, U29)

type Packed = U39

fn pack(self) -> <(U10, U29) as BitPack>::Packed

fn unpack(packed: <(U10, U29) as BitPack>::Packed) -> (U10, U29)

impl<T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T30, <(T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T30, <(T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U54, U6)

type Packed = U60

fn pack(self) -> <(U54, U6) as BitPack>::Packed

fn unpack(packed: <(U54, U6) as BitPack>::Packed) -> (U54, U6)

impl BitPack for (U6, U1)

type Packed = U7

fn pack(self) -> <(U6, U1) as BitPack>::Packed

fn unpack(packed: <(U6, U1) as BitPack>::Packed) -> (U6, U1)

impl BitPack for (U19, U30)

type Packed = U49

fn pack(self) -> <(U19, U30) as BitPack>::Packed

fn unpack(packed: <(U19, U30) as BitPack>::Packed) -> (U19, U30)

impl BitPack for (U3, U50)

type Packed = U53

fn pack(self) -> <(U3, U50) as BitPack>::Packed

fn unpack(packed: <(U3, U50) as BitPack>::Packed) -> (U3, U50)

impl BitPack for (U27, U26)

type Packed = U53

fn pack(self) -> <(U27, U26) as BitPack>::Packed

fn unpack(packed: <(U27, U26) as BitPack>::Packed) -> (U27, U26)

impl BitPack for (U40, U14)

type Packed = U54

fn pack(self) -> <(U40, U14) as BitPack>::Packed

fn unpack(packed: <(U40, U14) as BitPack>::Packed) -> (U40, U14)

impl BitPack for (U3, U54)

type Packed = U57

fn pack(self) -> <(U3, U54) as BitPack>::Packed

fn unpack(packed: <(U3, U54) as BitPack>::Packed) -> (U3, U54)

impl BitPack for (U34, U15)

type Packed = U49

fn pack(self) -> <(U34, U15) as BitPack>::Packed

fn unpack(packed: <(U34, U15) as BitPack>::Packed) -> (U34, U15)

impl BitPack for (U26, U35)

type Packed = U61

fn pack(self) -> <(U26, U35) as BitPack>::Packed

fn unpack(packed: <(U26, U35) as BitPack>::Packed) -> (U26, U35)

impl BitPack for (U52, U1)

type Packed = U53

fn pack(self) -> <(U52, U1) as BitPack>::Packed

fn unpack(packed: <(U52, U1) as BitPack>::Packed) -> (U52, U1)

impl BitPack for (U17, u32)

type Packed = U49

fn pack(self) -> <(U17, u32) as BitPack>::Packed

fn unpack(packed: <(U17, u32) as BitPack>::Packed) -> (U17, u32)

impl BitPack for (U12, U27)

type Packed = U39

fn pack(self) -> <(U12, U27) as BitPack>::Packed

fn unpack(packed: <(U12, U27) as BitPack>::Packed) -> (U12, U27)

impl BitPack for (U23, U2)

type Packed = U25

fn pack(self) -> <(U23, U2) as BitPack>::Packed

fn unpack(packed: <(U23, U2) as BitPack>::Packed) -> (U23, U2)

impl BitPack for (U6, U25)

type Packed = U31

fn pack(self) -> <(U6, U25) as BitPack>::Packed

fn unpack(packed: <(U6, U25) as BitPack>::Packed) -> (U6, U25)

impl BitPack for (U7, U28)

type Packed = U35

fn pack(self) -> <(U7, U28) as BitPack>::Packed

fn unpack(packed: <(U7, U28) as BitPack>::Packed) -> (U7, U28)

impl BitPack for (U31, U7)

type Packed = U38

fn pack(self) -> <(U31, U7) as BitPack>::Packed

fn unpack(packed: <(U31, U7) as BitPack>::Packed) -> (U31, U7)

impl BitPack for (U7, U20)

type Packed = U27

fn pack(self) -> <(U7, U20) as BitPack>::Packed

fn unpack(packed: <(U7, U20) as BitPack>::Packed) -> (U7, U20)

impl BitPack for (U38, U1)

type Packed = U39

fn pack(self) -> <(U38, U1) as BitPack>::Packed

fn unpack(packed: <(U38, U1) as BitPack>::Packed) -> (U38, U1)

impl BitPack for (U1, U20)

type Packed = U21

fn pack(self) -> <(U1, U20) as BitPack>::Packed

fn unpack(packed: <(U1, U20) as BitPack>::Packed) -> (U1, U20)

impl BitPack for (U4, U54)

type Packed = U58

fn pack(self) -> <(U4, U54) as BitPack>::Packed

fn unpack(packed: <(U4, U54) as BitPack>::Packed) -> (U4, U54)

impl BitPack for (U36, U24)

type Packed = U60

fn pack(self) -> <(U36, U24) as BitPack>::Packed

fn unpack(packed: <(U36, U24) as BitPack>::Packed) -> (U36, U24)

impl BitPack for (U29, U34)

type Packed = U63

fn pack(self) -> <(U29, U34) as BitPack>::Packed

fn unpack(packed: <(U29, U34) as BitPack>::Packed) -> (U29, U34)

impl BitPack for (U19, U24)

type Packed = U43

fn pack(self) -> <(U19, U24) as BitPack>::Packed

fn unpack(packed: <(U19, U24) as BitPack>::Packed) -> (U19, U24)

impl BitPack for (U22, U19)

type Packed = U41

fn pack(self) -> <(U22, U19) as BitPack>::Packed

fn unpack(packed: <(U22, U19) as BitPack>::Packed) -> (U22, U19)

impl BitPack for (u8, U22)

type Packed = U30

fn pack(self) -> <(u8, U22) as BitPack>::Packed

fn unpack(packed: <(u8, U22) as BitPack>::Packed) -> (u8, U22)

impl BitPack for (U13, U46)

type Packed = U59

fn pack(self) -> <(U13, U46) as BitPack>::Packed

fn unpack(packed: <(U13, U46) as BitPack>::Packed) -> (U13, U46)

impl BitPack for (U40, u8)

type Packed = U48

fn pack(self) -> <(U40, u8) as BitPack>::Packed

fn unpack(packed: <(U40, u8) as BitPack>::Packed) -> (U40, u8)

impl BitPack for (U24, U1)

type Packed = U25

fn pack(self) -> <(U24, U1) as BitPack>::Packed

fn unpack(packed: <(U24, U1) as BitPack>::Packed) -> (U24, U1)

impl BitPack for (U9, U7)

type Packed = u16

fn pack(self) -> <(U9, U7) as BitPack>::Packed

fn unpack(packed: <(U9, U7) as BitPack>::Packed) -> (U9, U7)

impl BitPack for (u32, U18)

type Packed = U50

fn pack(self) -> <(u32, U18) as BitPack>::Packed

fn unpack(packed: <(u32, U18) as BitPack>::Packed) -> (u32, U18)

impl BitPack for (u16, U34)

type Packed = U50

fn pack(self) -> <(u16, U34) as BitPack>::Packed

fn unpack(packed: <(u16, U34) as BitPack>::Packed) -> (u16, U34)

impl BitPack for (U23, U31)

type Packed = U54

fn pack(self) -> <(U23, U31) as BitPack>::Packed

fn unpack(packed: <(U23, U31) as BitPack>::Packed) -> (U23, U31)

impl BitPack for (U33, U21)

type Packed = U54

fn pack(self) -> <(U33, U21) as BitPack>::Packed

fn unpack(packed: <(U33, U21) as BitPack>::Packed) -> (U33, U21)

impl BitPack for (U6, U2)

type Packed = u8

fn pack(self) -> <(U6, U2) as BitPack>::Packed

fn unpack(packed: <(U6, U2) as BitPack>::Packed) -> (U6, U2)

impl BitPack for (U9, U14)

type Packed = U23

fn pack(self) -> <(U9, U14) as BitPack>::Packed

fn unpack(packed: <(U9, U14) as BitPack>::Packed) -> (U9, U14)

impl BitPack for (U38, U26)

type Packed = u64

fn pack(self) -> <(U38, U26) as BitPack>::Packed

fn unpack(packed: <(U38, U26) as BitPack>::Packed) -> (U38, U26)

impl BitPack for (U4, U20)

type Packed = U24

fn pack(self) -> <(U4, U20) as BitPack>::Packed

fn unpack(packed: <(U4, U20) as BitPack>::Packed) -> (U4, U20)

impl BitPack for (U35, U4)

type Packed = U39

fn pack(self) -> <(U35, U4) as BitPack>::Packed

fn unpack(packed: <(U35, U4) as BitPack>::Packed) -> (U35, U4)

impl BitPack for (u8, U33)

type Packed = U41

fn pack(self) -> <(u8, U33) as BitPack>::Packed

fn unpack(packed: <(u8, U33) as BitPack>::Packed) -> (u8, U33)

impl BitPack for (U13, U3)

type Packed = u16

fn pack(self) -> <(U13, U3) as BitPack>::Packed

fn unpack(packed: <(U13, U3) as BitPack>::Packed) -> (U13, U3)

impl BitPack for (U17, U11)

type Packed = U28

fn pack(self) -> <(U17, U11) as BitPack>::Packed

fn unpack(packed: <(U17, U11) as BitPack>::Packed) -> (U17, U11)

impl BitPack for (U6, U37)

type Packed = U43

fn pack(self) -> <(U6, U37) as BitPack>::Packed

fn unpack(packed: <(U6, U37) as BitPack>::Packed) -> (U6, U37)

impl BitPack for (U18, U25)

type Packed = U43

fn pack(self) -> <(U18, U25) as BitPack>::Packed

fn unpack(packed: <(U18, U25) as BitPack>::Packed) -> (U18, U25)

impl BitPack for (U37, U22)

type Packed = U59

fn pack(self) -> <(U37, U22) as BitPack>::Packed

fn unpack(packed: <(U37, U22) as BitPack>::Packed) -> (U37, U22)

impl BitPack for (U28, U13)

type Packed = U41

fn pack(self) -> <(U28, U13) as BitPack>::Packed

fn unpack(packed: <(U28, U13) as BitPack>::Packed) -> (U28, U13)

impl BitPack for (U34, U12)

type Packed = U46

fn pack(self) -> <(U34, U12) as BitPack>::Packed

fn unpack(packed: <(U34, U12) as BitPack>::Packed) -> (U34, U12)

impl BitPack for (U11, U19)

type Packed = U30

fn pack(self) -> <(U11, U19) as BitPack>::Packed

fn unpack(packed: <(U11, U19) as BitPack>::Packed) -> (U11, U19)

impl BitPack for (U36, U15)

type Packed = U51

fn pack(self) -> <(U36, U15) as BitPack>::Packed

fn unpack(packed: <(U36, U15) as BitPack>::Packed) -> (U36, U15)

impl BitPack for (U51, U4)

type Packed = U55

fn pack(self) -> <(U51, U4) as BitPack>::Packed

fn unpack(packed: <(U51, U4) as BitPack>::Packed) -> (U51, U4)

impl BitPack for (U31, U3)

type Packed = U34

fn pack(self) -> <(U31, U3) as BitPack>::Packed

fn unpack(packed: <(U31, U3) as BitPack>::Packed) -> (U31, U3)

impl BitPack for (U1, U15)

type Packed = u16

fn pack(self) -> <(U1, U15) as BitPack>::Packed

fn unpack(packed: <(U1, U15) as BitPack>::Packed) -> (U1, U15)

impl BitPack for (U40, U6)

type Packed = U46

fn pack(self) -> <(U40, U6) as BitPack>::Packed

fn unpack(packed: <(U40, U6) as BitPack>::Packed) -> (U40, U6)

impl BitPack for (U41, U11)

type Packed = U52

fn pack(self) -> <(U41, U11) as BitPack>::Packed

fn unpack(packed: <(U41, U11) as BitPack>::Packed) -> (U41, U11)

impl BitPack for (U26, U2)

type Packed = U28

fn pack(self) -> <(U26, U2) as BitPack>::Packed

fn unpack(packed: <(U26, U2) as BitPack>::Packed) -> (U26, U2)

impl BitPack for (U11, U52)

type Packed = U63

fn pack(self) -> <(U11, U52) as BitPack>::Packed

fn unpack(packed: <(U11, U52) as BitPack>::Packed) -> (U11, U52)

impl BitPack for (U31, U26)

type Packed = U57

fn pack(self) -> <(U31, U26) as BitPack>::Packed

fn unpack(packed: <(U31, U26) as BitPack>::Packed) -> (U31, U26)

impl BitPack for (U38, U22)

type Packed = U60

fn pack(self) -> <(U38, U22) as BitPack>::Packed

fn unpack(packed: <(U38, U22) as BitPack>::Packed) -> (U38, U22)

impl BitPack for (U19, U36)

type Packed = U55

fn pack(self) -> <(U19, U36) as BitPack>::Packed

fn unpack(packed: <(U19, U36) as BitPack>::Packed) -> (U19, U36)

impl BitPack for (U3, U38)

type Packed = U41

fn pack(self) -> <(U3, U38) as BitPack>::Packed

fn unpack(packed: <(U3, U38) as BitPack>::Packed) -> (U3, U38)

impl BitPack for (u8, U44)

type Packed = U52

fn pack(self) -> <(u8, U44) as BitPack>::Packed

fn unpack(packed: <(u8, U44) as BitPack>::Packed) -> (u8, U44)

impl BitPack for (U37, U21)

type Packed = U58

fn pack(self) -> <(U37, U21) as BitPack>::Packed

fn unpack(packed: <(U37, U21) as BitPack>::Packed) -> (U37, U21)

impl BitPack for (U23, U40)

type Packed = U63

fn pack(self) -> <(U23, U40) as BitPack>::Packed

fn unpack(packed: <(U23, U40) as BitPack>::Packed) -> (U23, U40)

impl BitPack for (u16, U36)

type Packed = U52

fn pack(self) -> <(u16, U36) as BitPack>::Packed

fn unpack(packed: <(u16, U36) as BitPack>::Packed) -> (u16, U36)

impl BitPack for (U9, U27)

type Packed = U36

fn pack(self) -> <(U9, U27) as BitPack>::Packed

fn unpack(packed: <(U9, U27) as BitPack>::Packed) -> (U9, U27)

impl BitPack for (U13, U11)

type Packed = U24

fn pack(self) -> <(U13, U11) as BitPack>::Packed

fn unpack(packed: <(U13, U11) as BitPack>::Packed) -> (U13, U11)

impl BitPack for (U22, U1)

type Packed = U23

fn pack(self) -> <(U22, U1) as BitPack>::Packed

fn unpack(packed: <(U22, U1) as BitPack>::Packed) -> (U22, U1)

impl BitPack for (U27, U5)

type Packed = u32

fn pack(self) -> <(U27, U5) as BitPack>::Packed

fn unpack(packed: <(U27, U5) as BitPack>::Packed) -> (U27, U5)

impl BitPack for (U23, U27)

type Packed = U50

fn pack(self) -> <(U23, U27) as BitPack>::Packed

fn unpack(packed: <(U23, U27) as BitPack>::Packed) -> (U23, U27)

impl BitPack for (U1, U12)

type Packed = U13

fn pack(self) -> <(U1, U12) as BitPack>::Packed

fn unpack(packed: <(U1, U12) as BitPack>::Packed) -> (U1, U12)

impl BitPack for (U3, U61)

type Packed = u64

fn pack(self) -> <(U3, U61) as BitPack>::Packed

fn unpack(packed: <(U3, U61) as BitPack>::Packed) -> (U3, U61)

impl BitPack for (U13, U18)

type Packed = U31

fn pack(self) -> <(U13, U18) as BitPack>::Packed

fn unpack(packed: <(U13, U18) as BitPack>::Packed) -> (U13, U18)

impl BitPack for (U6, U23)

type Packed = U29

fn pack(self) -> <(U6, U23) as BitPack>::Packed

fn unpack(packed: <(U6, U23) as BitPack>::Packed) -> (U6, U23)

impl BitPack for (U5, U10)

type Packed = U15

fn pack(self) -> <(U5, U10) as BitPack>::Packed

fn unpack(packed: <(U5, U10) as BitPack>::Packed) -> (U5, U10)

impl BitPack for (U6, U53)

type Packed = U59

fn pack(self) -> <(U6, U53) as BitPack>::Packed

fn unpack(packed: <(U6, U53) as BitPack>::Packed) -> (U6, U53)

impl BitPack for (U44, U1)

type Packed = U45

fn pack(self) -> <(U44, U1) as BitPack>::Packed

fn unpack(packed: <(U44, U1) as BitPack>::Packed) -> (U44, U1)

impl BitPack for (U21, U38)

type Packed = U59

fn pack(self) -> <(U21, U38) as BitPack>::Packed

fn unpack(packed: <(U21, U38) as BitPack>::Packed) -> (U21, U38)

impl BitPack for (U33, U3)

type Packed = U36

fn pack(self) -> <(U33, U3) as BitPack>::Packed

fn unpack(packed: <(U33, U3) as BitPack>::Packed) -> (U33, U3)

impl BitPack for (U15, U38)

type Packed = U53

fn pack(self) -> <(U15, U38) as BitPack>::Packed

fn unpack(packed: <(U15, U38) as BitPack>::Packed) -> (U15, U38)

impl BitPack for (U1, U33)

type Packed = U34

fn pack(self) -> <(U1, U33) as BitPack>::Packed

fn unpack(packed: <(U1, U33) as BitPack>::Packed) -> (U1, U33)

impl BitPack for (U31, u16)

type Packed = U47

fn pack(self) -> <(U31, u16) as BitPack>::Packed

fn unpack(packed: <(U31, u16) as BitPack>::Packed) -> (U31, u16)

impl BitPack for (U5, U23)

type Packed = U28

fn pack(self) -> <(U5, U23) as BitPack>::Packed

fn unpack(packed: <(U5, U23) as BitPack>::Packed) -> (U5, U23)

impl BitPack for (u8, U40)

type Packed = U48

fn pack(self) -> <(u8, U40) as BitPack>::Packed

fn unpack(packed: <(u8, U40) as BitPack>::Packed) -> (u8, U40)

impl BitPack for (U49, U14)

type Packed = U63

fn pack(self) -> <(U49, U14) as BitPack>::Packed

fn unpack(packed: <(U49, U14) as BitPack>::Packed) -> (U49, U14)

impl BitPack for (U48, U15)

type Packed = U63

fn pack(self) -> <(U48, U15) as BitPack>::Packed

fn unpack(packed: <(U48, U15) as BitPack>::Packed) -> (U48, U15)

impl BitPack for (U14, U40)

type Packed = U54

fn pack(self) -> <(U14, U40) as BitPack>::Packed

fn unpack(packed: <(U14, U40) as BitPack>::Packed) -> (U14, U40)

impl BitPack for (U12, U3)

type Packed = U15

fn pack(self) -> <(U12, U3) as BitPack>::Packed

fn unpack(packed: <(U12, U3) as BitPack>::Packed) -> (U12, U3)

impl BitPack for (U24, U30)

type Packed = U54

fn pack(self) -> <(U24, U30) as BitPack>::Packed

fn unpack(packed: <(U24, U30) as BitPack>::Packed) -> (U24, U30)

impl BitPack for (U5, U59)

type Packed = u64

fn pack(self) -> <(U5, U59) as BitPack>::Packed

fn unpack(packed: <(U5, U59) as BitPack>::Packed) -> (U5, U59)

impl BitPack for (U28, u32)

type Packed = U60

fn pack(self) -> <(U28, u32) as BitPack>::Packed

fn unpack(packed: <(U28, u32) as BitPack>::Packed) -> (U28, u32)

impl BitPack for (U49, U6)

type Packed = U55

fn pack(self) -> <(U49, U6) as BitPack>::Packed

fn unpack(packed: <(U49, U6) as BitPack>::Packed) -> (U49, U6)

impl BitPack for (U49, U4)

type Packed = U53

fn pack(self) -> <(U49, U4) as BitPack>::Packed

fn unpack(packed: <(U49, U4) as BitPack>::Packed) -> (U49, U4)

impl BitPack for (U21, U28)

type Packed = U49

fn pack(self) -> <(U21, U28) as BitPack>::Packed

fn unpack(packed: <(U21, U28) as BitPack>::Packed) -> (U21, U28)

impl BitPack for (U3, U35)

type Packed = U38

fn pack(self) -> <(U3, U35) as BitPack>::Packed

fn unpack(packed: <(U3, U35) as BitPack>::Packed) -> (U3, U35)

impl BitPack for (U26, U22)

type Packed = U48

fn pack(self) -> <(U26, U22) as BitPack>::Packed

fn unpack(packed: <(U26, U22) as BitPack>::Packed) -> (U26, U22)

impl BitPack for (U40, U15)

type Packed = U55

fn pack(self) -> <(U40, U15) as BitPack>::Packed

fn unpack(packed: <(U40, U15) as BitPack>::Packed) -> (U40, U15)

impl BitPack for (U11, U50)

type Packed = U61

fn pack(self) -> <(U11, U50) as BitPack>::Packed

fn unpack(packed: <(U11, U50) as BitPack>::Packed) -> (U11, U50)

impl BitPack for (U11, U53)

type Packed = u64

fn pack(self) -> <(U11, U53) as BitPack>::Packed

fn unpack(packed: <(U11, U53) as BitPack>::Packed) -> (U11, U53)

impl BitPack for (U12, U15)

type Packed = U27

fn pack(self) -> <(U12, U15) as BitPack>::Packed

fn unpack(packed: <(U12, U15) as BitPack>::Packed) -> (U12, U15)

impl BitPack for (U45, U1)

type Packed = U46

fn pack(self) -> <(U45, U1) as BitPack>::Packed

fn unpack(packed: <(U45, U1) as BitPack>::Packed) -> (U45, U1)

impl BitPack for (U5, U47)

type Packed = U52

fn pack(self) -> <(U5, U47) as BitPack>::Packed

fn unpack(packed: <(U5, U47) as BitPack>::Packed) -> (U5, U47)

impl BitPack for (U7, U4)

type Packed = U11

fn pack(self) -> <(U7, U4) as BitPack>::Packed

fn unpack(packed: <(U7, U4) as BitPack>::Packed) -> (U7, U4)

impl BitPack for (U29, u8)

type Packed = U37

fn pack(self) -> <(U29, u8) as BitPack>::Packed

fn unpack(packed: <(U29, u8) as BitPack>::Packed) -> (U29, u8)

impl BitPack for (U33, u8)

type Packed = U41

fn pack(self) -> <(U33, u8) as BitPack>::Packed

fn unpack(packed: <(U33, u8) as BitPack>::Packed) -> (U33, u8)

impl BitPack for (u16, U48)

type Packed = u64

fn pack(self) -> <(u16, U48) as BitPack>::Packed

fn unpack(packed: <(u16, U48) as BitPack>::Packed) -> (u16, U48)

impl BitPack for (U33, U13)

type Packed = U46

fn pack(self) -> <(U33, U13) as BitPack>::Packed

fn unpack(packed: <(U33, U13) as BitPack>::Packed) -> (U33, U13)

impl BitPack for (U23, U25)

type Packed = U48

fn pack(self) -> <(U23, U25) as BitPack>::Packed

fn unpack(packed: <(U23, U25) as BitPack>::Packed) -> (U23, U25)

impl BitPack for (U19, U26)

type Packed = U45

fn pack(self) -> <(U19, U26) as BitPack>::Packed

fn unpack(packed: <(U19, U26) as BitPack>::Packed) -> (U19, U26)

impl BitPack for (U27, U36)

type Packed = U63

fn pack(self) -> <(U27, U36) as BitPack>::Packed

fn unpack(packed: <(U27, U36) as BitPack>::Packed) -> (U27, U36)

impl BitPack for (U4, U19)

type Packed = U23

fn pack(self) -> <(U4, U19) as BitPack>::Packed

fn unpack(packed: <(U4, U19) as BitPack>::Packed) -> (U4, U19)

impl BitPack for (U24, U15)

type Packed = U39

fn pack(self) -> <(U24, U15) as BitPack>::Packed

fn unpack(packed: <(U24, U15) as BitPack>::Packed) -> (U24, U15)

impl BitPack for (U1, U62)

type Packed = U63

fn pack(self) -> <(U1, U62) as BitPack>::Packed

fn unpack(packed: <(U1, U62) as BitPack>::Packed) -> (U1, U62)

impl BitPack for (U10, u8)

type Packed = U18

fn pack(self) -> <(U10, u8) as BitPack>::Packed

fn unpack(packed: <(U10, u8) as BitPack>::Packed) -> (U10, u8)

impl BitPack for (U26, U37)

type Packed = U63

fn pack(self) -> <(U26, U37) as BitPack>::Packed

fn unpack(packed: <(U26, U37) as BitPack>::Packed) -> (U26, U37)

impl BitPack for (U23, U10)

type Packed = U33

fn pack(self) -> <(U23, U10) as BitPack>::Packed

fn unpack(packed: <(U23, U10) as BitPack>::Packed) -> (U23, U10)

impl BitPack for (U4, U1)

type Packed = U5

fn pack(self) -> <(U4, U1) as BitPack>::Packed

fn unpack(packed: <(U4, U1) as BitPack>::Packed) -> (U4, U1)

impl BitPack for (U13, U24)

type Packed = U37

fn pack(self) -> <(U13, U24) as BitPack>::Packed

fn unpack(packed: <(U13, U24) as BitPack>::Packed) -> (U13, U24)

impl BitPack for (U15, U15)

type Packed = U30

fn pack(self) -> <(U15, U15) as BitPack>::Packed

fn unpack(packed: <(U15, U15) as BitPack>::Packed) -> (U15, U15)

impl BitPack for (U36, u8)

type Packed = U44

fn pack(self) -> <(U36, u8) as BitPack>::Packed

fn unpack(packed: <(U36, u8) as BitPack>::Packed) -> (U36, u8)

impl BitPack for (U14, U49)

type Packed = U63

fn pack(self) -> <(U14, U49) as BitPack>::Packed

fn unpack(packed: <(U14, U49) as BitPack>::Packed) -> (U14, U49)

impl BitPack for (U7, U49)

type Packed = U56

fn pack(self) -> <(U7, U49) as BitPack>::Packed

fn unpack(packed: <(U7, U49) as BitPack>::Packed) -> (U7, U49)

impl BitPack for (U3, U30)

type Packed = U33

fn pack(self) -> <(U3, U30) as BitPack>::Packed

fn unpack(packed: <(U3, U30) as BitPack>::Packed) -> (U3, U30)

impl BitPack for (U47, U10)

type Packed = U57

fn pack(self) -> <(U47, U10) as BitPack>::Packed

fn unpack(packed: <(U47, U10) as BitPack>::Packed) -> (U47, U10)

impl BitPack for (U24, U21)

type Packed = U45

fn pack(self) -> <(U24, U21) as BitPack>::Packed

fn unpack(packed: <(U24, U21) as BitPack>::Packed) -> (U24, U21)

impl BitPack for (U22, U30)

type Packed = U52

fn pack(self) -> <(U22, U30) as BitPack>::Packed

fn unpack(packed: <(U22, U30) as BitPack>::Packed) -> (U22, U30)

impl BitPack for (U5, U30)

type Packed = U35

fn pack(self) -> <(U5, U30) as BitPack>::Packed

fn unpack(packed: <(U5, U30) as BitPack>::Packed) -> (U5, U30)

impl BitPack for (U4, U38)

type Packed = U42

fn pack(self) -> <(U4, U38) as BitPack>::Packed

fn unpack(packed: <(U4, U38) as BitPack>::Packed) -> (U4, U38)

impl BitPack for (U33, U26)

type Packed = U59

fn pack(self) -> <(U33, U26) as BitPack>::Packed

fn unpack(packed: <(U33, U26) as BitPack>::Packed) -> (U33, U26)

impl BitPack for (U43, U5)

type Packed = U48

fn pack(self) -> <(U43, U5) as BitPack>::Packed

fn unpack(packed: <(U43, U5) as BitPack>::Packed) -> (U43, U5)

impl BitPack for (U11, U17)

type Packed = U28

fn pack(self) -> <(U11, U17) as BitPack>::Packed

fn unpack(packed: <(U11, U17) as BitPack>::Packed) -> (U11, U17)

impl BitPack for (U42, U3)

type Packed = U45

fn pack(self) -> <(U42, U3) as BitPack>::Packed

fn unpack(packed: <(U42, U3) as BitPack>::Packed) -> (U42, U3)

impl BitPack for (U3, u32)

type Packed = U35

fn pack(self) -> <(U3, u32) as BitPack>::Packed

fn unpack(packed: <(U3, u32) as BitPack>::Packed) -> (U3, u32)

impl BitPack for (U27, u32)

type Packed = U59

fn pack(self) -> <(U27, u32) as BitPack>::Packed

fn unpack(packed: <(U27, u32) as BitPack>::Packed) -> (U27, u32)

impl BitPack for (U26, U26)

type Packed = U52

fn pack(self) -> <(U26, U26) as BitPack>::Packed

fn unpack(packed: <(U26, U26) as BitPack>::Packed) -> (U26, U26)

impl BitPack for (U6, U11)

type Packed = U17

fn pack(self) -> <(U6, U11) as BitPack>::Packed

fn unpack(packed: <(U6, U11) as BitPack>::Packed) -> (U6, U11)

impl BitPack for (U23, U4)

type Packed = U27

fn pack(self) -> <(U23, U4) as BitPack>::Packed

fn unpack(packed: <(U23, U4) as BitPack>::Packed) -> (U23, U4)

impl BitPack for (U35, U25)

type Packed = U60

fn pack(self) -> <(U35, U25) as BitPack>::Packed

fn unpack(packed: <(U35, U25) as BitPack>::Packed) -> (U35, U25)

impl BitPack for (U5, u8)

type Packed = U13

fn pack(self) -> <(U5, u8) as BitPack>::Packed

fn unpack(packed: <(U5, u8) as BitPack>::Packed) -> (U5, u8)

impl BitPack for (U7, U10)

type Packed = U17

fn pack(self) -> <(U7, U10) as BitPack>::Packed

fn unpack(packed: <(U7, U10) as BitPack>::Packed) -> (U7, U10)

impl BitPack for (u8, U34)

type Packed = U42

fn pack(self) -> <(u8, U34) as BitPack>::Packed

fn unpack(packed: <(u8, U34) as BitPack>::Packed) -> (u8, U34)

impl BitPack for (u16, U19)

type Packed = U35

fn pack(self) -> <(u16, U19) as BitPack>::Packed

fn unpack(packed: <(u16, U19) as BitPack>::Packed) -> (u16, U19)

impl BitPack for (U30, U3)

type Packed = U33

fn pack(self) -> <(U30, U3) as BitPack>::Packed

fn unpack(packed: <(U30, U3) as BitPack>::Packed) -> (U30, U3)

impl BitPack for (U21, u16)

type Packed = U37

fn pack(self) -> <(U21, u16) as BitPack>::Packed

fn unpack(packed: <(U21, u16) as BitPack>::Packed) -> (U21, u16)

impl BitPack for (U11, U7)

type Packed = U18

fn pack(self) -> <(U11, U7) as BitPack>::Packed

fn unpack(packed: <(U11, U7) as BitPack>::Packed) -> (U11, U7)

impl BitPack for (U34, U14)

type Packed = U48

fn pack(self) -> <(U34, U14) as BitPack>::Packed

fn unpack(packed: <(U34, U14) as BitPack>::Packed) -> (U34, U14)

impl BitPack for (U20, U28)

type Packed = U48

fn pack(self) -> <(U20, U28) as BitPack>::Packed

fn unpack(packed: <(U20, U28) as BitPack>::Packed) -> (U20, U28)

impl BitPack for (U9, U4)

type Packed = U13

fn pack(self) -> <(U9, U4) as BitPack>::Packed

fn unpack(packed: <(U9, U4) as BitPack>::Packed) -> (U9, U4)

impl BitPack for (U2, u16)

type Packed = U18

fn pack(self) -> <(U2, u16) as BitPack>::Packed

fn unpack(packed: <(U2, u16) as BitPack>::Packed) -> (U2, u16)

impl BitPack for (U15, U31)

type Packed = U46

fn pack(self) -> <(U15, U31) as BitPack>::Packed

fn unpack(packed: <(U15, U31) as BitPack>::Packed) -> (U15, U31)

impl BitPack for (U20, U18)

type Packed = U38

fn pack(self) -> <(U20, U18) as BitPack>::Packed

fn unpack(packed: <(U20, U18) as BitPack>::Packed) -> (U20, U18)

impl BitPack for (U12, U21)

type Packed = U33

fn pack(self) -> <(U12, U21) as BitPack>::Packed

fn unpack(packed: <(U12, U21) as BitPack>::Packed) -> (U12, U21)

impl BitPack for (U38, u16)

type Packed = U54

fn pack(self) -> <(U38, u16) as BitPack>::Packed

fn unpack(packed: <(U38, u16) as BitPack>::Packed) -> (U38, u16)

impl BitPack for (U19, U21)

type Packed = U40

fn pack(self) -> <(U19, U21) as BitPack>::Packed

fn unpack(packed: <(U19, U21) as BitPack>::Packed) -> (U19, U21)

impl BitPack for (U13, U49)

type Packed = U62

fn pack(self) -> <(U13, U49) as BitPack>::Packed

fn unpack(packed: <(U13, U49) as BitPack>::Packed) -> (U13, U49)

impl BitPack for (U21, U30)

type Packed = U51

fn pack(self) -> <(U21, U30) as BitPack>::Packed

fn unpack(packed: <(U21, U30) as BitPack>::Packed) -> (U21, U30)

impl<T58, T59, T60, T61, T62, T63, T64> BitPack for (T58, T59, T60, T61, T62, T63, T64)where
    (T59, T60, T61, T62, T63, T64): BitPack,
    (T58, <(T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T58, <(T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(self) -> <(T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U53, U11)

type Packed = u64

fn pack(self) -> <(U53, U11) as BitPack>::Packed

fn unpack(packed: <(U53, U11) as BitPack>::Packed) -> (U53, U11)

impl BitPack for (U22, U28)

type Packed = U50

fn pack(self) -> <(U22, U28) as BitPack>::Packed

fn unpack(packed: <(U22, U28) as BitPack>::Packed) -> (U22, U28)

impl BitPack for (U25, U21)

type Packed = U46

fn pack(self) -> <(U25, U21) as BitPack>::Packed

fn unpack(packed: <(U25, U21) as BitPack>::Packed) -> (U25, U21)

impl BitPack for (U34, U18)

type Packed = U52

fn pack(self) -> <(U34, U18) as BitPack>::Packed

fn unpack(packed: <(U34, U18) as BitPack>::Packed) -> (U34, U18)

impl BitPack for (U9, u8)

type Packed = U17

fn pack(self) -> <(U9, u8) as BitPack>::Packed

fn unpack(packed: <(U9, u8) as BitPack>::Packed) -> (U9, u8)

impl BitPack for (U31, U17)

type Packed = U48

fn pack(self) -> <(U31, U17) as BitPack>::Packed

fn unpack(packed: <(U31, U17) as BitPack>::Packed) -> (U31, U17)

impl BitPack for (U62, U2)

type Packed = u64

fn pack(self) -> <(U62, U2) as BitPack>::Packed

fn unpack(packed: <(U62, U2) as BitPack>::Packed) -> (U62, U2)

impl BitPack for (U19, U34)

type Packed = U53

fn pack(self) -> <(U19, U34) as BitPack>::Packed

fn unpack(packed: <(U19, U34) as BitPack>::Packed) -> (U19, U34)

impl BitPack for (U60, U3)

type Packed = U63

fn pack(self) -> <(U60, U3) as BitPack>::Packed

fn unpack(packed: <(U60, U3) as BitPack>::Packed) -> (U60, U3)

impl BitPack for (U47, U7)

type Packed = U54

fn pack(self) -> <(U47, U7) as BitPack>::Packed

fn unpack(packed: <(U47, U7) as BitPack>::Packed) -> (U47, U7)

impl BitPack for (U19, U27)

type Packed = U46

fn pack(self) -> <(U19, U27) as BitPack>::Packed

fn unpack(packed: <(U19, U27) as BitPack>::Packed) -> (U19, U27)

impl BitPack for (U36, U19)

type Packed = U55

fn pack(self) -> <(U36, U19) as BitPack>::Packed

fn unpack(packed: <(U36, U19) as BitPack>::Packed) -> (U36, U19)

impl BitPack for (U40, U22)

type Packed = U62

fn pack(self) -> <(U40, U22) as BitPack>::Packed

fn unpack(packed: <(U40, U22) as BitPack>::Packed) -> (U40, U22)

impl BitPack for (U6, U42)

type Packed = U48

fn pack(self) -> <(U6, U42) as BitPack>::Packed

fn unpack(packed: <(U6, U42) as BitPack>::Packed) -> (U6, U42)

impl BitPack for (U12, U33)

type Packed = U45

fn pack(self) -> <(U12, U33) as BitPack>::Packed

fn unpack(packed: <(U12, U33) as BitPack>::Packed) -> (U12, U33)

impl BitPack for (U40, U9)

type Packed = U49

fn pack(self) -> <(U40, U9) as BitPack>::Packed

fn unpack(packed: <(U40, U9) as BitPack>::Packed) -> (U40, U9)

impl BitPack for (U9, U47)

type Packed = U56

fn pack(self) -> <(U9, U47) as BitPack>::Packed

fn unpack(packed: <(U9, U47) as BitPack>::Packed) -> (U9, U47)

impl BitPack for (U1, U41)

type Packed = U42

fn pack(self) -> <(U1, U41) as BitPack>::Packed

fn unpack(packed: <(U1, U41) as BitPack>::Packed) -> (U1, U41)

impl BitPack for (U26, U19)

type Packed = U45

fn pack(self) -> <(U26, U19) as BitPack>::Packed

fn unpack(packed: <(U26, U19) as BitPack>::Packed) -> (U26, U19)

impl BitPack for (U15, U33)

type Packed = U48

fn pack(self) -> <(U15, U33) as BitPack>::Packed

fn unpack(packed: <(U15, U33) as BitPack>::Packed) -> (U15, U33)

impl BitPack for (U19, U12)

type Packed = U31

fn pack(self) -> <(U19, U12) as BitPack>::Packed

fn unpack(packed: <(U19, U12) as BitPack>::Packed) -> (U19, U12)

impl BitPack for (U10, U9)

type Packed = U19

fn pack(self) -> <(U10, U9) as BitPack>::Packed

fn unpack(packed: <(U10, U9) as BitPack>::Packed) -> (U10, U9)

impl BitPack for (U12, U19)

type Packed = U31

fn pack(self) -> <(U12, U19) as BitPack>::Packed

fn unpack(packed: <(U12, U19) as BitPack>::Packed) -> (U12, U19)

impl BitPack for (U36, U9)

type Packed = U45

fn pack(self) -> <(U36, U9) as BitPack>::Packed

fn unpack(packed: <(U36, U9) as BitPack>::Packed) -> (U36, U9)

impl BitPack for (U39, U7)

type Packed = U46

fn pack(self) -> <(U39, U7) as BitPack>::Packed

fn unpack(packed: <(U39, U7) as BitPack>::Packed) -> (U39, U7)

impl BitPack for (U4, U11)

type Packed = U15

fn pack(self) -> <(U4, U11) as BitPack>::Packed

fn unpack(packed: <(U4, U11) as BitPack>::Packed) -> (U4, U11)

impl BitPack for (u32, u16)

type Packed = U48

fn pack(self) -> <(u32, u16) as BitPack>::Packed

fn unpack(packed: <(u32, u16) as BitPack>::Packed) -> (u32, u16)

impl BitPack for (U18, U28)

type Packed = U46

fn pack(self) -> <(U18, U28) as BitPack>::Packed

fn unpack(packed: <(U18, U28) as BitPack>::Packed) -> (U18, U28)

impl BitPack for (U10, U28)

type Packed = U38

fn pack(self) -> <(U10, U28) as BitPack>::Packed

fn unpack(packed: <(U10, U28) as BitPack>::Packed) -> (U10, U28)

impl BitPack for (U28, U7)

type Packed = U35

fn pack(self) -> <(U28, U7) as BitPack>::Packed

fn unpack(packed: <(U28, U7) as BitPack>::Packed) -> (U28, U7)

impl BitPack for (u16, U42)

type Packed = U58

fn pack(self) -> <(u16, U42) as BitPack>::Packed

fn unpack(packed: <(u16, U42) as BitPack>::Packed) -> (u16, U42)

impl BitPack for (U23, U24)

type Packed = U47

fn pack(self) -> <(U23, U24) as BitPack>::Packed

fn unpack(packed: <(U23, U24) as BitPack>::Packed) -> (U23, U24)

impl BitPack for (U28, U2)

type Packed = U30

fn pack(self) -> <(U28, U2) as BitPack>::Packed

fn unpack(packed: <(U28, U2) as BitPack>::Packed) -> (U28, U2)

impl BitPack for (U26, U36)

type Packed = U62

fn pack(self) -> <(U26, U36) as BitPack>::Packed

fn unpack(packed: <(U26, U36) as BitPack>::Packed) -> (U26, U36)

impl BitPack for (U57, U2)

type Packed = U59

fn pack(self) -> <(U57, U2) as BitPack>::Packed

fn unpack(packed: <(U57, U2) as BitPack>::Packed) -> (U57, U2)

impl BitPack for (U18, U20)

type Packed = U38

fn pack(self) -> <(U18, U20) as BitPack>::Packed

fn unpack(packed: <(U18, U20) as BitPack>::Packed) -> (U18, U20)

impl BitPack for (U1, U5)

type Packed = U6

fn pack(self) -> <(U1, U5) as BitPack>::Packed

fn unpack(packed: <(U1, U5) as BitPack>::Packed) -> (U1, U5)

impl BitPack for (U15, U27)

type Packed = U42

fn pack(self) -> <(U15, U27) as BitPack>::Packed

fn unpack(packed: <(U15, U27) as BitPack>::Packed) -> (U15, U27)

impl BitPack for (U48, u8)

type Packed = U56

fn pack(self) -> <(U48, u8) as BitPack>::Packed

fn unpack(packed: <(U48, u8) as BitPack>::Packed) -> (U48, u8)

impl BitPack for (U29, U13)

type Packed = U42

fn pack(self) -> <(U29, U13) as BitPack>::Packed

fn unpack(packed: <(U29, U13) as BitPack>::Packed) -> (U29, U13)

impl BitPack for (U15, U35)

type Packed = U50

fn pack(self) -> <(U15, U35) as BitPack>::Packed

fn unpack(packed: <(U15, U35) as BitPack>::Packed) -> (U15, U35)

impl BitPack for (U27, U15)

type Packed = U42

fn pack(self) -> <(U27, U15) as BitPack>::Packed

fn unpack(packed: <(U27, U15) as BitPack>::Packed) -> (U27, U15)

impl BitPack for (U15, U4)

type Packed = U19

fn pack(self) -> <(U15, U4) as BitPack>::Packed

fn unpack(packed: <(U15, U4) as BitPack>::Packed) -> (U15, U4)

impl BitPack for (U30, u32)

type Packed = U62

fn pack(self) -> <(U30, u32) as BitPack>::Packed

fn unpack(packed: <(U30, u32) as BitPack>::Packed) -> (U30, u32)

impl BitPack for (U14, u16)

type Packed = U30

fn pack(self) -> <(U14, u16) as BitPack>::Packed

fn unpack(packed: <(U14, u16) as BitPack>::Packed) -> (U14, u16)

impl BitPack for (U4, U60)

type Packed = u64

fn pack(self) -> <(U4, U60) as BitPack>::Packed

fn unpack(packed: <(U4, U60) as BitPack>::Packed) -> (U4, U60)

impl BitPack for (U17, U42)

type Packed = U59

fn pack(self) -> <(U17, U42) as BitPack>::Packed

fn unpack(packed: <(U17, U42) as BitPack>::Packed) -> (U17, U42)

impl BitPack for (U4, U14)

type Packed = U18

fn pack(self) -> <(U4, U14) as BitPack>::Packed

fn unpack(packed: <(U4, U14) as BitPack>::Packed) -> (U4, U14)

impl BitPack for (U12, U24)

type Packed = U36

fn pack(self) -> <(U12, U24) as BitPack>::Packed

fn unpack(packed: <(U12, U24) as BitPack>::Packed) -> (U12, U24)

impl BitPack for (U10, U15)

type Packed = U25

fn pack(self) -> <(U10, U15) as BitPack>::Packed

fn unpack(packed: <(U10, U15) as BitPack>::Packed) -> (U10, U15)

impl BitPack for (U44, U9)

type Packed = U53

fn pack(self) -> <(U44, U9) as BitPack>::Packed

fn unpack(packed: <(U44, U9) as BitPack>::Packed) -> (U44, U9)

impl BitPack for (U28, U28)

type Packed = U56

fn pack(self) -> <(U28, U28) as BitPack>::Packed

fn unpack(packed: <(U28, U28) as BitPack>::Packed) -> (U28, U28)

impl BitPack for (U11, U23)

type Packed = U34

fn pack(self) -> <(U11, U23) as BitPack>::Packed

fn unpack(packed: <(U11, U23) as BitPack>::Packed) -> (U11, U23)

impl BitPack for (U2, U38)

type Packed = U40

fn pack(self) -> <(U2, U38) as BitPack>::Packed

fn unpack(packed: <(U2, U38) as BitPack>::Packed) -> (U2, U38)

impl BitPack for (U24, U33)

type Packed = U57

fn pack(self) -> <(U24, U33) as BitPack>::Packed

fn unpack(packed: <(U24, U33) as BitPack>::Packed) -> (U24, U33)

impl BitPack for (u8, U20)

type Packed = U28

fn pack(self) -> <(u8, U20) as BitPack>::Packed

fn unpack(packed: <(u8, U20) as BitPack>::Packed) -> (u8, U20)

impl BitPack for (U4, U47)

type Packed = U51

fn pack(self) -> <(U4, U47) as BitPack>::Packed

fn unpack(packed: <(U4, U47) as BitPack>::Packed) -> (U4, U47)

impl BitPack for (U13, U14)

type Packed = U27

fn pack(self) -> <(U13, U14) as BitPack>::Packed

fn unpack(packed: <(U13, U14) as BitPack>::Packed) -> (U13, U14)

impl BitPack for (U11, U2)

type Packed = U13

fn pack(self) -> <(U11, U2) as BitPack>::Packed

fn unpack(packed: <(U11, U2) as BitPack>::Packed) -> (U11, U2)

impl BitPack for (U29, U1)

type Packed = U30

fn pack(self) -> <(U29, U1) as BitPack>::Packed

fn unpack(packed: <(U29, U1) as BitPack>::Packed) -> (U29, U1)

impl<T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T40, <(T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T40, <(T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U27, U9)

type Packed = U36

fn pack(self) -> <(U27, U9) as BitPack>::Packed

fn unpack(packed: <(U27, U9) as BitPack>::Packed) -> (U27, U9)

impl BitPack for (U25, U11)

type Packed = U36

fn pack(self) -> <(U25, U11) as BitPack>::Packed

fn unpack(packed: <(U25, U11) as BitPack>::Packed) -> (U25, U11)

impl BitPack for (U47, U9)

type Packed = U56

fn pack(self) -> <(U47, U9) as BitPack>::Packed

fn unpack(packed: <(U47, U9) as BitPack>::Packed) -> (U47, U9)

impl BitPack for (U31, U18)

type Packed = U49

fn pack(self) -> <(U31, U18) as BitPack>::Packed

fn unpack(packed: <(U31, U18) as BitPack>::Packed) -> (U31, U18)

impl BitPack for (U48, U10)

type Packed = U58

fn pack(self) -> <(U48, U10) as BitPack>::Packed

fn unpack(packed: <(U48, U10) as BitPack>::Packed) -> (U48, U10)

impl BitPack for (U41, U10)

type Packed = U51

fn pack(self) -> <(U41, U10) as BitPack>::Packed

fn unpack(packed: <(U41, U10) as BitPack>::Packed) -> (U41, U10)

impl BitPack for (U24, U12)

type Packed = U36

fn pack(self) -> <(U24, U12) as BitPack>::Packed

fn unpack(packed: <(U24, U12) as BitPack>::Packed) -> (U24, U12)

impl BitPack for (U39, U9)

type Packed = U48

fn pack(self) -> <(U39, U9) as BitPack>::Packed

fn unpack(packed: <(U39, U9) as BitPack>::Packed) -> (U39, U9)

impl BitPack for (U41, U17)

type Packed = U58

fn pack(self) -> <(U41, U17) as BitPack>::Packed

fn unpack(packed: <(U41, U17) as BitPack>::Packed) -> (U41, U17)

impl BitPack for (U37, U10)

type Packed = U47

fn pack(self) -> <(U37, U10) as BitPack>::Packed

fn unpack(packed: <(U37, U10) as BitPack>::Packed) -> (U37, U10)

impl BitPack for (U9, U21)

type Packed = U30

fn pack(self) -> <(U9, U21) as BitPack>::Packed

fn unpack(packed: <(U9, U21) as BitPack>::Packed) -> (U9, U21)

impl BitPack for (U20, U13)

type Packed = U33

fn pack(self) -> <(U20, U13) as BitPack>::Packed

fn unpack(packed: <(U20, U13) as BitPack>::Packed) -> (U20, U13)

impl BitPack for (U40, U7)

type Packed = U47

fn pack(self) -> <(U40, U7) as BitPack>::Packed

fn unpack(packed: <(U40, U7) as BitPack>::Packed) -> (U40, U7)

impl BitPack for (U2, U28)

type Packed = U30

fn pack(self) -> <(U2, U28) as BitPack>::Packed

fn unpack(packed: <(U2, U28) as BitPack>::Packed) -> (U2, U28)

impl BitPack for (U4, U33)

type Packed = U37

fn pack(self) -> <(U4, U33) as BitPack>::Packed

fn unpack(packed: <(U4, U33) as BitPack>::Packed) -> (U4, U33)

impl BitPack for (U4, U22)

type Packed = U26

fn pack(self) -> <(U4, U22) as BitPack>::Packed

fn unpack(packed: <(U4, U22) as BitPack>::Packed) -> (U4, U22)

impl BitPack for (U6, U34)

type Packed = U40

fn pack(self) -> <(U6, U34) as BitPack>::Packed

fn unpack(packed: <(U6, U34) as BitPack>::Packed) -> (U6, U34)

impl BitPack for (u32, U22)

type Packed = U54

fn pack(self) -> <(u32, U22) as BitPack>::Packed

fn unpack(packed: <(u32, U22) as BitPack>::Packed) -> (u32, U22)

impl BitPack for (U19, U23)

type Packed = U42

fn pack(self) -> <(U19, U23) as BitPack>::Packed

fn unpack(packed: <(U19, U23) as BitPack>::Packed) -> (U19, U23)

impl BitPack for (U14, U12)

type Packed = U26

fn pack(self) -> <(U14, U12) as BitPack>::Packed

fn unpack(packed: <(U14, U12) as BitPack>::Packed) -> (U14, U12)

impl BitPack for (u16, U38)

type Packed = U54

fn pack(self) -> <(u16, U38) as BitPack>::Packed

fn unpack(packed: <(u16, U38) as BitPack>::Packed) -> (u16, U38)

impl BitPack for (U3, U10)

type Packed = U13

fn pack(self) -> <(U3, U10) as BitPack>::Packed

fn unpack(packed: <(U3, U10) as BitPack>::Packed) -> (U3, U10)

impl BitPack for (U27, U2)

type Packed = U29

fn pack(self) -> <(U27, U2) as BitPack>::Packed

fn unpack(packed: <(U27, U2) as BitPack>::Packed) -> (U27, U2)

impl BitPack for (U24, U20)

type Packed = U44

fn pack(self) -> <(U24, U20) as BitPack>::Packed

fn unpack(packed: <(U24, U20) as BitPack>::Packed) -> (U24, U20)

impl BitPack for (U25, U2)

type Packed = U27

fn pack(self) -> <(U25, U2) as BitPack>::Packed

fn unpack(packed: <(U25, U2) as BitPack>::Packed) -> (U25, U2)

impl BitPack for (U20, U36)

type Packed = U56

fn pack(self) -> <(U20, U36) as BitPack>::Packed

fn unpack(packed: <(U20, U36) as BitPack>::Packed) -> (U20, U36)

impl BitPack for (U36, U13)

type Packed = U49

fn pack(self) -> <(U36, U13) as BitPack>::Packed

fn unpack(packed: <(U36, U13) as BitPack>::Packed) -> (U36, U13)

impl BitPack for (U23, U23)

type Packed = U46

fn pack(self) -> <(U23, U23) as BitPack>::Packed

fn unpack(packed: <(U23, U23) as BitPack>::Packed) -> (U23, U23)

impl BitPack for (U48, U2)

type Packed = U50

fn pack(self) -> <(U48, U2) as BitPack>::Packed

fn unpack(packed: <(U48, U2) as BitPack>::Packed) -> (U48, U2)

impl BitPack for (U11, U51)

type Packed = U62

fn pack(self) -> <(U11, U51) as BitPack>::Packed

fn unpack(packed: <(U11, U51) as BitPack>::Packed) -> (U11, U51)

impl BitPack for (U55, U7)

type Packed = U62

fn pack(self) -> <(U55, U7) as BitPack>::Packed

fn unpack(packed: <(U55, U7) as BitPack>::Packed) -> (U55, U7)

impl BitPack for (U39, U24)

type Packed = U63

fn pack(self) -> <(U39, U24) as BitPack>::Packed

fn unpack(packed: <(U39, U24) as BitPack>::Packed) -> (U39, U24)

impl BitPack for (U1, U53)

type Packed = U54

fn pack(self) -> <(U1, U53) as BitPack>::Packed

fn unpack(packed: <(U1, U53) as BitPack>::Packed) -> (U1, U53)

impl BitPack for (U17, U17)

type Packed = U34

fn pack(self) -> <(U17, U17) as BitPack>::Packed

fn unpack(packed: <(U17, U17) as BitPack>::Packed) -> (U17, U17)

impl BitPack for (u32, U28)

type Packed = U60

fn pack(self) -> <(u32, U28) as BitPack>::Packed

fn unpack(packed: <(u32, U28) as BitPack>::Packed) -> (u32, U28)

impl BitPack for (U13, U23)

type Packed = U36

fn pack(self) -> <(U13, U23) as BitPack>::Packed

fn unpack(packed: <(U13, U23) as BitPack>::Packed) -> (U13, U23)

impl BitPack for (U20, U9)

type Packed = U29

fn pack(self) -> <(U20, U9) as BitPack>::Packed

fn unpack(packed: <(U20, U9) as BitPack>::Packed) -> (U20, U9)

impl BitPack for (U50, U12)

type Packed = U62

fn pack(self) -> <(U50, U12) as BitPack>::Packed

fn unpack(packed: <(U50, U12) as BitPack>::Packed) -> (U50, U12)

impl BitPack for (U46, U17)

type Packed = U63

fn pack(self) -> <(U46, U17) as BitPack>::Packed

fn unpack(packed: <(U46, U17) as BitPack>::Packed) -> (U46, U17)

impl BitPack for (U24, U5)

type Packed = U29

fn pack(self) -> <(U24, U5) as BitPack>::Packed

fn unpack(packed: <(U24, U5) as BitPack>::Packed) -> (U24, U5)

impl BitPack for (U25, U18)

type Packed = U43

fn pack(self) -> <(U25, U18) as BitPack>::Packed

fn unpack(packed: <(U25, U18) as BitPack>::Packed) -> (U25, U18)

impl BitPack for (U5, U45)

type Packed = U50

fn pack(self) -> <(U5, U45) as BitPack>::Packed

fn unpack(packed: <(U5, U45) as BitPack>::Packed) -> (U5, U45)

impl BitPack for (u32, U29)

type Packed = U61

fn pack(self) -> <(u32, U29) as BitPack>::Packed

fn unpack(packed: <(u32, U29) as BitPack>::Packed) -> (u32, U29)

impl BitPack for (U11, U22)

type Packed = U33

fn pack(self) -> <(U11, U22) as BitPack>::Packed

fn unpack(packed: <(U11, U22) as BitPack>::Packed) -> (U11, U22)

impl BitPack for (U20, U17)

type Packed = U37

fn pack(self) -> <(U20, U17) as BitPack>::Packed

fn unpack(packed: <(U20, U17) as BitPack>::Packed) -> (U20, U17)

impl BitPack for (u8, U18)

type Packed = U26

fn pack(self) -> <(u8, U18) as BitPack>::Packed

fn unpack(packed: <(u8, U18) as BitPack>::Packed) -> (u8, U18)

impl<T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T45, <(T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T45, <(T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U5, U34)

type Packed = U39

fn pack(self) -> <(U5, U34) as BitPack>::Packed

fn unpack(packed: <(U5, U34) as BitPack>::Packed) -> (U5, U34)

impl BitPack for (U13, U1)

type Packed = U14

fn pack(self) -> <(U13, U1) as BitPack>::Packed

fn unpack(packed: <(U13, U1) as BitPack>::Packed) -> (U13, U1)

impl BitPack for (U36, U27)

type Packed = U63

fn pack(self) -> <(U36, U27) as BitPack>::Packed

fn unpack(packed: <(U36, U27) as BitPack>::Packed) -> (U36, U27)

impl BitPack for (U3, U5)

type Packed = u8

fn pack(self) -> <(U3, U5) as BitPack>::Packed

fn unpack(packed: <(U3, U5) as BitPack>::Packed) -> (U3, U5)

impl BitPack for (U17, U28)

type Packed = U45

fn pack(self) -> <(U17, U28) as BitPack>::Packed

fn unpack(packed: <(U17, U28) as BitPack>::Packed) -> (U17, U28)

impl BitPack for (U39, U13)

type Packed = U52

fn pack(self) -> <(U39, U13) as BitPack>::Packed

fn unpack(packed: <(U39, U13) as BitPack>::Packed) -> (U39, U13)

impl BitPack for (U25, U19)

type Packed = U44

fn pack(self) -> <(U25, U19) as BitPack>::Packed

fn unpack(packed: <(U25, U19) as BitPack>::Packed) -> (U25, U19)

impl BitPack for (U14, U19)

type Packed = U33

fn pack(self) -> <(U14, U19) as BitPack>::Packed

fn unpack(packed: <(U14, U19) as BitPack>::Packed) -> (U14, U19)

impl BitPack for (U7, U56)

type Packed = U63

fn pack(self) -> <(U7, U56) as BitPack>::Packed

fn unpack(packed: <(U7, U56) as BitPack>::Packed) -> (U7, U56)

impl BitPack for (U5, U11)

type Packed = u16

fn pack(self) -> <(U5, U11) as BitPack>::Packed

fn unpack(packed: <(U5, U11) as BitPack>::Packed) -> (U5, U11)

impl BitPack for (U17, U1)

type Packed = U18

fn pack(self) -> <(U17, U1) as BitPack>::Packed

fn unpack(packed: <(U17, U1) as BitPack>::Packed) -> (U17, U1)

impl BitPack for (U46, U2)

type Packed = U48

fn pack(self) -> <(U46, U2) as BitPack>::Packed

fn unpack(packed: <(U46, U2) as BitPack>::Packed) -> (U46, U2)

impl<T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T43, <(T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T43, <(T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U12, U34)

type Packed = U46

fn pack(self) -> <(U12, U34) as BitPack>::Packed

fn unpack(packed: <(U12, U34) as BitPack>::Packed) -> (U12, U34)

impl BitPack for (U13, U51)

type Packed = u64

fn pack(self) -> <(U13, U51) as BitPack>::Packed

fn unpack(packed: <(U13, U51) as BitPack>::Packed) -> (U13, U51)

impl BitPack for (U24, U6)

type Packed = U30

fn pack(self) -> <(U24, U6) as BitPack>::Packed

fn unpack(packed: <(U24, U6) as BitPack>::Packed) -> (U24, U6)

impl BitPack for (U14, U38)

type Packed = U52

fn pack(self) -> <(U14, U38) as BitPack>::Packed

fn unpack(packed: <(U14, U38) as BitPack>::Packed) -> (U14, U38)

impl BitPack for (U22, U3)

type Packed = U25

fn pack(self) -> <(U22, U3) as BitPack>::Packed

fn unpack(packed: <(U22, U3) as BitPack>::Packed) -> (U22, U3)

impl BitPack for (U34, U11)

type Packed = U45

fn pack(self) -> <(U34, U11) as BitPack>::Packed

fn unpack(packed: <(U34, U11) as BitPack>::Packed) -> (U34, U11)

impl BitPack for (U2, U19)

type Packed = U21

fn pack(self) -> <(U2, U19) as BitPack>::Packed

fn unpack(packed: <(U2, U19) as BitPack>::Packed) -> (U2, U19)

impl BitPack for (U5, U4)

type Packed = U9

fn pack(self) -> <(U5, U4) as BitPack>::Packed

fn unpack(packed: <(U5, U4) as BitPack>::Packed) -> (U5, U4)

impl BitPack for (U14, U2)

type Packed = u16

fn pack(self) -> <(U14, U2) as BitPack>::Packed

fn unpack(packed: <(U14, U2) as BitPack>::Packed) -> (U14, U2)

impl BitPack for (U20, U5)

type Packed = U25

fn pack(self) -> <(U20, U5) as BitPack>::Packed

fn unpack(packed: <(U20, U5) as BitPack>::Packed) -> (U20, U5)

impl BitPack for (U54, U1)

type Packed = U55

fn pack(self) -> <(U54, U1) as BitPack>::Packed

fn unpack(packed: <(U54, U1) as BitPack>::Packed) -> (U54, U1)

impl BitPack for (U36, U7)

type Packed = U43

fn pack(self) -> <(U36, U7) as BitPack>::Packed

fn unpack(packed: <(U36, U7) as BitPack>::Packed) -> (U36, U7)

impl BitPack for (U37, U2)

type Packed = U39

fn pack(self) -> <(U37, U2) as BitPack>::Packed

fn unpack(packed: <(U37, U2) as BitPack>::Packed) -> (U37, U2)

impl BitPack for (U45, U6)

type Packed = U51

fn pack(self) -> <(U45, U6) as BitPack>::Packed

fn unpack(packed: <(U45, U6) as BitPack>::Packed) -> (U45, U6)

impl BitPack for (u16, U21)

type Packed = U37

fn pack(self) -> <(u16, U21) as BitPack>::Packed

fn unpack(packed: <(u16, U21) as BitPack>::Packed) -> (u16, U21)

impl BitPack for (U2, U43)

type Packed = U45

fn pack(self) -> <(U2, U43) as BitPack>::Packed

fn unpack(packed: <(U2, U43) as BitPack>::Packed) -> (U2, U43)

impl BitPack for (U25, u8)

type Packed = U33

fn pack(self) -> <(U25, u8) as BitPack>::Packed

fn unpack(packed: <(U25, u8) as BitPack>::Packed) -> (U25, u8)

impl<T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T9, <(T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T9, <(T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U33, U18)

type Packed = U51

fn pack(self) -> <(U33, U18) as BitPack>::Packed

fn unpack(packed: <(U33, U18) as BitPack>::Packed) -> (U33, U18)

impl BitPack for (U15, U13)

type Packed = U28

fn pack(self) -> <(U15, U13) as BitPack>::Packed

fn unpack(packed: <(U15, U13) as BitPack>::Packed) -> (U15, U13)

impl BitPack for (U58, U6)

type Packed = u64

fn pack(self) -> <(U58, U6) as BitPack>::Packed

fn unpack(packed: <(U58, U6) as BitPack>::Packed) -> (U58, U6)

impl BitPack for (U24, U35)

type Packed = U59

fn pack(self) -> <(U24, U35) as BitPack>::Packed

fn unpack(packed: <(U24, U35) as BitPack>::Packed) -> (U24, U35)

impl BitPack for (U2, U20)

type Packed = U22

fn pack(self) -> <(U2, U20) as BitPack>::Packed

fn unpack(packed: <(U2, U20) as BitPack>::Packed) -> (U2, U20)

impl BitPack for (U1, U30)

type Packed = U31

fn pack(self) -> <(U1, U30) as BitPack>::Packed

fn unpack(packed: <(U1, U30) as BitPack>::Packed) -> (U1, U30)

impl BitPack for (U6, U35)

type Packed = U41

fn pack(self) -> <(U6, U35) as BitPack>::Packed

fn unpack(packed: <(U6, U35) as BitPack>::Packed) -> (U6, U35)

impl BitPack for (U1, U59)

type Packed = U60

fn pack(self) -> <(U1, U59) as BitPack>::Packed

fn unpack(packed: <(U1, U59) as BitPack>::Packed) -> (U1, U59)

impl BitPack for (U6, U30)

type Packed = U36

fn pack(self) -> <(U6, U30) as BitPack>::Packed

fn unpack(packed: <(U6, U30) as BitPack>::Packed) -> (U6, U30)

impl BitPack for (U21, U23)

type Packed = U44

fn pack(self) -> <(U21, U23) as BitPack>::Packed

fn unpack(packed: <(U21, U23) as BitPack>::Packed) -> (U21, U23)

impl BitPack for (u16, U26)

type Packed = U42

fn pack(self) -> <(u16, U26) as BitPack>::Packed

fn unpack(packed: <(u16, U26) as BitPack>::Packed) -> (u16, U26)

impl BitPack for (U21, u8)

type Packed = U29

fn pack(self) -> <(U21, u8) as BitPack>::Packed

fn unpack(packed: <(U21, u8) as BitPack>::Packed) -> (U21, u8)

impl BitPack for (u8, U39)

type Packed = U47

fn pack(self) -> <(u8, U39) as BitPack>::Packed

fn unpack(packed: <(u8, U39) as BitPack>::Packed) -> (u8, U39)

impl BitPack for (U15, U1)

type Packed = u16

fn pack(self) -> <(U15, U1) as BitPack>::Packed

fn unpack(packed: <(U15, U1) as BitPack>::Packed) -> (U15, U1)

impl BitPack for (U2, U6)

type Packed = u8

fn pack(self) -> <(U2, U6) as BitPack>::Packed

fn unpack(packed: <(U2, U6) as BitPack>::Packed) -> (U2, U6)

impl BitPack for (U39, u8)

type Packed = U47

fn pack(self) -> <(U39, u8) as BitPack>::Packed

fn unpack(packed: <(U39, u8) as BitPack>::Packed) -> (U39, u8)

impl BitPack for (u8, U2)

type Packed = U10

fn pack(self) -> <(u8, U2) as BitPack>::Packed

fn unpack(packed: <(u8, U2) as BitPack>::Packed) -> (u8, U2)

impl BitPack for (U14, U42)

type Packed = U56

fn pack(self) -> <(U14, U42) as BitPack>::Packed

fn unpack(packed: <(U14, U42) as BitPack>::Packed) -> (U14, U42)

impl BitPack for (U34, U2)

type Packed = U36

fn pack(self) -> <(U34, U2) as BitPack>::Packed

fn unpack(packed: <(U34, U2) as BitPack>::Packed) -> (U34, U2)

impl BitPack for (U27, U11)

type Packed = U38

fn pack(self) -> <(U27, U11) as BitPack>::Packed

fn unpack(packed: <(U27, U11) as BitPack>::Packed) -> (U27, U11)

impl BitPack for (U12, U20)

type Packed = u32

fn pack(self) -> <(U12, U20) as BitPack>::Packed

fn unpack(packed: <(U12, U20) as BitPack>::Packed) -> (U12, U20)

impl<T62, T63, T64> BitPack for (T62, T63, T64)where
    (T63, T64): BitPack,
    (T62, <(T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T62, <(T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(self) -> <(T62, T63, T64) as BitPack>::Packed

fn unpack(packed: <(T62, T63, T64) as BitPack>::Packed) -> (T62, T63, T64)

impl<T60, T61, T62, T63, T64> BitPack for (T60, T61, T62, T63, T64)where
    (T61, T62, T63, T64): BitPack,
    (T60, <(T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T60, <(T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(self) -> <(T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T60, T61, T62, T63, T64)

impl BitPack for (U4, U45)

type Packed = U49

fn pack(self) -> <(U4, U45) as BitPack>::Packed

fn unpack(packed: <(U4, U45) as BitPack>::Packed) -> (U4, U45)

impl BitPack for (U2, U9)

type Packed = U11

fn pack(self) -> <(U2, U9) as BitPack>::Packed

fn unpack(packed: <(U2, U9) as BitPack>::Packed) -> (U2, U9)

impl BitPack for (U5, U14)

type Packed = U19

fn pack(self) -> <(U5, U14) as BitPack>::Packed

fn unpack(packed: <(U5, U14) as BitPack>::Packed) -> (U5, U14)

impl BitPack for (U56, U1)

type Packed = U57

fn pack(self) -> <(U56, U1) as BitPack>::Packed

fn unpack(packed: <(U56, U1) as BitPack>::Packed) -> (U56, U1)

impl BitPack for (U48, U5)

type Packed = U53

fn pack(self) -> <(U48, U5) as BitPack>::Packed

fn unpack(packed: <(U48, U5) as BitPack>::Packed) -> (U48, U5)

impl BitPack for (U13, u16)

type Packed = U29

fn pack(self) -> <(U13, u16) as BitPack>::Packed

fn unpack(packed: <(U13, u16) as BitPack>::Packed) -> (U13, u16)

impl BitPack for (U9, U12)

type Packed = U21

fn pack(self) -> <(U9, U12) as BitPack>::Packed

fn unpack(packed: <(U9, U12) as BitPack>::Packed) -> (U9, U12)

impl BitPack for (U5, U26)

type Packed = U31

fn pack(self) -> <(U5, U26) as BitPack>::Packed

fn unpack(packed: <(U5, U26) as BitPack>::Packed) -> (U5, U26)

impl BitPack for (U2, U17)

type Packed = U19

fn pack(self) -> <(U2, U17) as BitPack>::Packed

fn unpack(packed: <(U2, U17) as BitPack>::Packed) -> (U2, U17)

impl BitPack for (U17, U19)

type Packed = U36

fn pack(self) -> <(U17, U19) as BitPack>::Packed

fn unpack(packed: <(U17, U19) as BitPack>::Packed) -> (U17, U19)

impl BitPack for (U22, U6)

type Packed = U28

fn pack(self) -> <(U22, U6) as BitPack>::Packed

fn unpack(packed: <(U22, U6) as BitPack>::Packed) -> (U22, U6)

impl BitPack for (U58, U1)

type Packed = U59

fn pack(self) -> <(U58, U1) as BitPack>::Packed

fn unpack(packed: <(U58, U1) as BitPack>::Packed) -> (U58, U1)

impl BitPack for (U17, U12)

type Packed = U29

fn pack(self) -> <(U17, U12) as BitPack>::Packed

fn unpack(packed: <(U17, U12) as BitPack>::Packed) -> (U17, U12)

impl BitPack for (U6, U27)

type Packed = U33

fn pack(self) -> <(U6, U27) as BitPack>::Packed

fn unpack(packed: <(U6, U27) as BitPack>::Packed) -> (U6, U27)

impl<T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T24, <(T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T24, <(T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U11, U18)

type Packed = U29

fn pack(self) -> <(U11, U18) as BitPack>::Packed

fn unpack(packed: <(U11, U18) as BitPack>::Packed) -> (U11, U18)

impl BitPack for (U14, U22)

type Packed = U36

fn pack(self) -> <(U14, U22) as BitPack>::Packed

fn unpack(packed: <(U14, U22) as BitPack>::Packed) -> (U14, U22)

impl BitPack for (U4, U28)

type Packed = u32

fn pack(self) -> <(U4, U28) as BitPack>::Packed

fn unpack(packed: <(U4, U28) as BitPack>::Packed) -> (U4, U28)

impl BitPack for (U5, U19)

type Packed = U24

fn pack(self) -> <(U5, U19) as BitPack>::Packed

fn unpack(packed: <(U5, U19) as BitPack>::Packed) -> (U5, U19)

impl BitPack for (U28, U17)

type Packed = U45

fn pack(self) -> <(U28, U17) as BitPack>::Packed

fn unpack(packed: <(U28, U17) as BitPack>::Packed) -> (U28, U17)

impl BitPack for (U18, U5)

type Packed = U23

fn pack(self) -> <(U18, U5) as BitPack>::Packed

fn unpack(packed: <(U18, U5) as BitPack>::Packed) -> (U18, U5)

impl BitPack for (U42, U4)

type Packed = U46

fn pack(self) -> <(U42, U4) as BitPack>::Packed

fn unpack(packed: <(U42, U4) as BitPack>::Packed) -> (U42, U4)

impl BitPack for (U22, U14)

type Packed = U36

fn pack(self) -> <(U22, U14) as BitPack>::Packed

fn unpack(packed: <(U22, U14) as BitPack>::Packed) -> (U22, U14)

impl BitPack for (U33, U5)

type Packed = U38

fn pack(self) -> <(U33, U5) as BitPack>::Packed

fn unpack(packed: <(U33, U5) as BitPack>::Packed) -> (U33, U5)

impl BitPack for (U14, U15)

type Packed = U29

fn pack(self) -> <(U14, U15) as BitPack>::Packed

fn unpack(packed: <(U14, U15) as BitPack>::Packed) -> (U14, U15)

impl BitPack for (U21, U42)

type Packed = U63

fn pack(self) -> <(U21, U42) as BitPack>::Packed

fn unpack(packed: <(U21, U42) as BitPack>::Packed) -> (U21, U42)

impl BitPack for (U29, U25)

type Packed = U54

fn pack(self) -> <(U29, U25) as BitPack>::Packed

fn unpack(packed: <(U29, U25) as BitPack>::Packed) -> (U29, U25)

impl BitPack for (U6, U52)

type Packed = U58

fn pack(self) -> <(U6, U52) as BitPack>::Packed

fn unpack(packed: <(U6, U52) as BitPack>::Packed) -> (U6, U52)

impl BitPack for (U20, U43)

type Packed = U63

fn pack(self) -> <(U20, U43) as BitPack>::Packed

fn unpack(packed: <(U20, U43) as BitPack>::Packed) -> (U20, U43)

impl BitPack for (U9, U45)

type Packed = U54

fn pack(self) -> <(U9, U45) as BitPack>::Packed

fn unpack(packed: <(U9, U45) as BitPack>::Packed) -> (U9, U45)

impl BitPack for (U15, U47)

type Packed = U62

fn pack(self) -> <(U15, U47) as BitPack>::Packed

fn unpack(packed: <(U15, U47) as BitPack>::Packed) -> (U15, U47)

impl BitPack for (U21, U40)

type Packed = U61

fn pack(self) -> <(U21, U40) as BitPack>::Packed

fn unpack(packed: <(U21, U40) as BitPack>::Packed) -> (U21, U40)

impl BitPack for (U44, U5)

type Packed = U49

fn pack(self) -> <(U44, U5) as BitPack>::Packed

fn unpack(packed: <(U44, U5) as BitPack>::Packed) -> (U44, U5)

impl BitPack for (U27, U14)

type Packed = U41

fn pack(self) -> <(U27, U14) as BitPack>::Packed

fn unpack(packed: <(U27, U14) as BitPack>::Packed) -> (U27, U14)

impl BitPack for (U34, U5)

type Packed = U39

fn pack(self) -> <(U34, U5) as BitPack>::Packed

fn unpack(packed: <(U34, U5) as BitPack>::Packed) -> (U34, U5)

impl BitPack for (U27, U20)

type Packed = U47

fn pack(self) -> <(U27, U20) as BitPack>::Packed

fn unpack(packed: <(U27, U20) as BitPack>::Packed) -> (U27, U20)

impl BitPack for (U45, U7)

type Packed = U52

fn pack(self) -> <(U45, U7) as BitPack>::Packed

fn unpack(packed: <(U45, U7) as BitPack>::Packed) -> (U45, U7)

impl BitPack for (U24, U19)

type Packed = U43

fn pack(self) -> <(U24, U19) as BitPack>::Packed

fn unpack(packed: <(U24, U19) as BitPack>::Packed) -> (U24, U19)

impl BitPack for (u8, U19)

type Packed = U27

fn pack(self) -> <(u8, U19) as BitPack>::Packed

fn unpack(packed: <(u8, U19) as BitPack>::Packed) -> (u8, U19)

impl BitPack for (U49, U11)

type Packed = U60

fn pack(self) -> <(U49, U11) as BitPack>::Packed

fn unpack(packed: <(U49, U11) as BitPack>::Packed) -> (U49, U11)

impl BitPack for (U38, U4)

type Packed = U42

fn pack(self) -> <(U38, U4) as BitPack>::Packed

fn unpack(packed: <(U38, U4) as BitPack>::Packed) -> (U38, U4)

impl BitPack for (U36, u16)

type Packed = U52

fn pack(self) -> <(U36, u16) as BitPack>::Packed

fn unpack(packed: <(U36, u16) as BitPack>::Packed) -> (U36, u16)

impl BitPack for (U24, U29)

type Packed = U53

fn pack(self) -> <(U24, U29) as BitPack>::Packed

fn unpack(packed: <(U24, U29) as BitPack>::Packed) -> (U24, U29)

impl BitPack for (u8, u16)

type Packed = U24

fn pack(self) -> <(u8, u16) as BitPack>::Packed

fn unpack(packed: <(u8, u16) as BitPack>::Packed) -> (u8, u16)

impl BitPack for (U25, U9)

type Packed = U34

fn pack(self) -> <(U25, U9) as BitPack>::Packed

fn unpack(packed: <(U25, U9) as BitPack>::Packed) -> (U25, U9)

impl BitPack for (u16, U40)

type Packed = U56

fn pack(self) -> <(u16, U40) as BitPack>::Packed

fn unpack(packed: <(u16, U40) as BitPack>::Packed) -> (u16, U40)

impl BitPack for (U63, U1)

type Packed = u64

fn pack(self) -> <(U63, U1) as BitPack>::Packed

fn unpack(packed: <(U63, U1) as BitPack>::Packed) -> (U63, U1)

impl BitPack for (U24, U26)

type Packed = U50

fn pack(self) -> <(U24, U26) as BitPack>::Packed

fn unpack(packed: <(U24, U26) as BitPack>::Packed) -> (U24, U26)

impl BitPack for (U3, U48)

type Packed = U51

fn pack(self) -> <(U3, U48) as BitPack>::Packed

fn unpack(packed: <(U3, U48) as BitPack>::Packed) -> (U3, U48)

impl BitPack for (U23, U30)

type Packed = U53

fn pack(self) -> <(U23, U30) as BitPack>::Packed

fn unpack(packed: <(U23, U30) as BitPack>::Packed) -> (U23, U30)

impl BitPack for (U30, U23)

type Packed = U53

fn pack(self) -> <(U30, U23) as BitPack>::Packed

fn unpack(packed: <(U30, U23) as BitPack>::Packed) -> (U30, U23)

impl BitPack for (U9, U44)

type Packed = U53

fn pack(self) -> <(U9, U44) as BitPack>::Packed

fn unpack(packed: <(U9, U44) as BitPack>::Packed) -> (U9, U44)

impl BitPack for (U15, U9)

type Packed = U24

fn pack(self) -> <(U15, U9) as BitPack>::Packed

fn unpack(packed: <(U15, U9) as BitPack>::Packed) -> (U15, U9)

impl BitPack for (U46, U10)

type Packed = U56

fn pack(self) -> <(U46, U10) as BitPack>::Packed

fn unpack(packed: <(U46, U10) as BitPack>::Packed) -> (U46, U10)

impl BitPack for (U9, U46)

type Packed = U55

fn pack(self) -> <(U9, U46) as BitPack>::Packed

fn unpack(packed: <(U9, U46) as BitPack>::Packed) -> (U9, U46)

impl BitPack for (U30, U17)

type Packed = U47

fn pack(self) -> <(U30, U17) as BitPack>::Packed

fn unpack(packed: <(U30, U17) as BitPack>::Packed) -> (U30, U17)

impl BitPack for (U20, U40)

type Packed = U60

fn pack(self) -> <(U20, U40) as BitPack>::Packed

fn unpack(packed: <(U20, U40) as BitPack>::Packed) -> (U20, U40)

impl BitPack for (u32, U6)

type Packed = U38

fn pack(self) -> <(u32, U6) as BitPack>::Packed

fn unpack(packed: <(u32, U6) as BitPack>::Packed) -> (u32, U6)

impl BitPack for (U38, U18)

type Packed = U56

fn pack(self) -> <(U38, U18) as BitPack>::Packed

fn unpack(packed: <(U38, U18) as BitPack>::Packed) -> (U38, U18)

impl BitPack for (U26, U28)

type Packed = U54

fn pack(self) -> <(U26, U28) as BitPack>::Packed

fn unpack(packed: <(U26, U28) as BitPack>::Packed) -> (U26, U28)

impl BitPack for (U10, U1)

type Packed = U11

fn pack(self) -> <(U10, U1) as BitPack>::Packed

fn unpack(packed: <(U10, U1) as BitPack>::Packed) -> (U10, U1)

impl BitPack for (U2, U40)

type Packed = U42

fn pack(self) -> <(U2, U40) as BitPack>::Packed

fn unpack(packed: <(U2, U40) as BitPack>::Packed) -> (U2, U40)

impl BitPack for (U38, U17)

type Packed = U55

fn pack(self) -> <(U38, U17) as BitPack>::Packed

fn unpack(packed: <(U38, U17) as BitPack>::Packed) -> (U38, U17)

impl BitPack for (U43, U7)

type Packed = U50

fn pack(self) -> <(U43, U7) as BitPack>::Packed

fn unpack(packed: <(U43, U7) as BitPack>::Packed) -> (U43, U7)

impl BitPack for (U9, u32)

type Packed = U41

fn pack(self) -> <(U9, u32) as BitPack>::Packed

fn unpack(packed: <(U9, u32) as BitPack>::Packed) -> (U9, u32)

impl BitPack for (U7, U13)

type Packed = U20

fn pack(self) -> <(U7, U13) as BitPack>::Packed

fn unpack(packed: <(U7, U13) as BitPack>::Packed) -> (U7, U13)

impl BitPack for (U60, U2)

type Packed = U62

fn pack(self) -> <(U60, U2) as BitPack>::Packed

fn unpack(packed: <(U60, U2) as BitPack>::Packed) -> (U60, U2)

impl BitPack for (U14, U13)

type Packed = U27

fn pack(self) -> <(U14, U13) as BitPack>::Packed

fn unpack(packed: <(U14, U13) as BitPack>::Packed) -> (U14, U13)

impl BitPack for (U1, U44)

type Packed = U45

fn pack(self) -> <(U1, U44) as BitPack>::Packed

fn unpack(packed: <(U1, U44) as BitPack>::Packed) -> (U1, U44)

impl BitPack for (U38, U6)

type Packed = U44

fn pack(self) -> <(U38, U6) as BitPack>::Packed

fn unpack(packed: <(U38, U6) as BitPack>::Packed) -> (U38, U6)

impl BitPack for (U2, U26)

type Packed = U28

fn pack(self) -> <(U2, U26) as BitPack>::Packed

fn unpack(packed: <(U2, U26) as BitPack>::Packed) -> (U2, U26)

impl BitPack for (U30, U12)

type Packed = U42

fn pack(self) -> <(U30, U12) as BitPack>::Packed

fn unpack(packed: <(U30, U12) as BitPack>::Packed) -> (U30, U12)

impl BitPack for (U29, U3)

type Packed = u32

fn pack(self) -> <(U29, U3) as BitPack>::Packed

fn unpack(packed: <(U29, U3) as BitPack>::Packed) -> (U29, U3)

impl BitPack for (U4, U50)

type Packed = U54

fn pack(self) -> <(U4, U50) as BitPack>::Packed

fn unpack(packed: <(U4, U50) as BitPack>::Packed) -> (U4, U50)

impl BitPack for (U17, U26)

type Packed = U43

fn pack(self) -> <(U17, U26) as BitPack>::Packed

fn unpack(packed: <(U17, U26) as BitPack>::Packed) -> (U17, U26)

impl BitPack for (U30, U31)

type Packed = U61

fn pack(self) -> <(U30, U31) as BitPack>::Packed

fn unpack(packed: <(U30, U31) as BitPack>::Packed) -> (U30, U31)

impl BitPack for (U22, U41)

type Packed = U63

fn pack(self) -> <(U22, U41) as BitPack>::Packed

fn unpack(packed: <(U22, U41) as BitPack>::Packed) -> (U22, U41)

impl BitPack for (U14, U47)

type Packed = U61

fn pack(self) -> <(U14, U47) as BitPack>::Packed

fn unpack(packed: <(U14, U47) as BitPack>::Packed) -> (U14, U47)

impl BitPack for (U9, U38)

type Packed = U47

fn pack(self) -> <(U9, U38) as BitPack>::Packed

fn unpack(packed: <(U9, U38) as BitPack>::Packed) -> (U9, U38)

impl BitPack for (U9, U51)

type Packed = U60

fn pack(self) -> <(U9, U51) as BitPack>::Packed

fn unpack(packed: <(U9, U51) as BitPack>::Packed) -> (U9, U51)

impl BitPack for (U20, U35)

type Packed = U55

fn pack(self) -> <(U20, U35) as BitPack>::Packed

fn unpack(packed: <(U20, U35) as BitPack>::Packed) -> (U20, U35)

impl BitPack for (U2, U14)

type Packed = u16

fn pack(self) -> <(U2, U14) as BitPack>::Packed

fn unpack(packed: <(U2, U14) as BitPack>::Packed) -> (U2, U14)

impl BitPack for (U9, U2)

type Packed = U11

fn pack(self) -> <(U9, U2) as BitPack>::Packed

fn unpack(packed: <(U9, U2) as BitPack>::Packed) -> (U9, U2)

impl BitPack for (U17, U33)

type Packed = U50

fn pack(self) -> <(U17, U33) as BitPack>::Packed

fn unpack(packed: <(U17, U33) as BitPack>::Packed) -> (U17, U33)

impl BitPack for (U42, U1)

type Packed = U43

fn pack(self) -> <(U42, U1) as BitPack>::Packed

fn unpack(packed: <(U42, U1) as BitPack>::Packed) -> (U42, U1)

impl BitPack for (U4, U2)

type Packed = U6

fn pack(self) -> <(U4, U2) as BitPack>::Packed

fn unpack(packed: <(U4, U2) as BitPack>::Packed) -> (U4, U2)

impl BitPack for (U3, U36)

type Packed = U39

fn pack(self) -> <(U3, U36) as BitPack>::Packed

fn unpack(packed: <(U3, U36) as BitPack>::Packed) -> (U3, U36)

impl BitPack for (U47, U5)

type Packed = U52

fn pack(self) -> <(U47, U5) as BitPack>::Packed

fn unpack(packed: <(U47, U5) as BitPack>::Packed) -> (U47, U5)

impl BitPack for (U20, U10)

type Packed = U30

fn pack(self) -> <(U20, U10) as BitPack>::Packed

fn unpack(packed: <(U20, U10) as BitPack>::Packed) -> (U20, U10)

impl BitPack for (U54, U9)

type Packed = U63

fn pack(self) -> <(U54, U9) as BitPack>::Packed

fn unpack(packed: <(U54, U9) as BitPack>::Packed) -> (U54, U9)

impl BitPack for (U45, U18)

type Packed = U63

fn pack(self) -> <(U45, U18) as BitPack>::Packed

fn unpack(packed: <(U45, U18) as BitPack>::Packed) -> (U45, U18)

impl BitPack for (U36, U1)

type Packed = U37

fn pack(self) -> <(U36, U1) as BitPack>::Packed

fn unpack(packed: <(U36, U1) as BitPack>::Packed) -> (U36, U1)

impl BitPack for (U17, U2)

type Packed = U19

fn pack(self) -> <(U17, U2) as BitPack>::Packed

fn unpack(packed: <(U17, U2) as BitPack>::Packed) -> (U17, U2)

impl BitPack for (U45, U9)

type Packed = U54

fn pack(self) -> <(U45, U9) as BitPack>::Packed

fn unpack(packed: <(U45, U9) as BitPack>::Packed) -> (U45, U9)

impl BitPack for (U34, U9)

type Packed = U43

fn pack(self) -> <(U34, U9) as BitPack>::Packed

fn unpack(packed: <(U34, U9) as BitPack>::Packed) -> (U34, U9)

impl BitPack for (U20, U31)

type Packed = U51

fn pack(self) -> <(U20, U31) as BitPack>::Packed

fn unpack(packed: <(U20, U31) as BitPack>::Packed) -> (U20, U31)

impl BitPack for (U39, U5)

type Packed = U44

fn pack(self) -> <(U39, U5) as BitPack>::Packed

fn unpack(packed: <(U39, U5) as BitPack>::Packed) -> (U39, U5)

impl BitPack for (U17, U27)

type Packed = U44

fn pack(self) -> <(U17, U27) as BitPack>::Packed

fn unpack(packed: <(U17, U27) as BitPack>::Packed) -> (U17, U27)

impl BitPack for (U12, U37)

type Packed = U49

fn pack(self) -> <(U12, U37) as BitPack>::Packed

fn unpack(packed: <(U12, U37) as BitPack>::Packed) -> (U12, U37)

impl BitPack for (U47, U3)

type Packed = U50

fn pack(self) -> <(U47, U3) as BitPack>::Packed

fn unpack(packed: <(U47, U3) as BitPack>::Packed) -> (U47, U3)

impl BitPack for (U7, U43)

type Packed = U50

fn pack(self) -> <(U7, U43) as BitPack>::Packed

fn unpack(packed: <(U7, U43) as BitPack>::Packed) -> (U7, U43)

impl BitPack for (U14, U25)

type Packed = U39

fn pack(self) -> <(U14, U25) as BitPack>::Packed

fn unpack(packed: <(U14, U25) as BitPack>::Packed) -> (U14, U25)

impl BitPack for (U19, U40)

type Packed = U59

fn pack(self) -> <(U19, U40) as BitPack>::Packed

fn unpack(packed: <(U19, U40) as BitPack>::Packed) -> (U19, U40)

impl BitPack for (u32, U27)

type Packed = U59

fn pack(self) -> <(u32, U27) as BitPack>::Packed

fn unpack(packed: <(u32, U27) as BitPack>::Packed) -> (u32, U27)

impl BitPack for (U48, U4)

type Packed = U52

fn pack(self) -> <(U48, U4) as BitPack>::Packed

fn unpack(packed: <(U48, U4) as BitPack>::Packed) -> (U48, U4)

impl BitPack for (U14, U33)

type Packed = U47

fn pack(self) -> <(U14, U33) as BitPack>::Packed

fn unpack(packed: <(U14, U33) as BitPack>::Packed) -> (U14, U33)

impl BitPack for (U14, U4)

type Packed = U18

fn pack(self) -> <(U14, U4) as BitPack>::Packed

fn unpack(packed: <(U14, U4) as BitPack>::Packed) -> (U14, U4)

impl BitPack for (U18, U15)

type Packed = U33

fn pack(self) -> <(U18, U15) as BitPack>::Packed

fn unpack(packed: <(U18, U15) as BitPack>::Packed) -> (U18, U15)

impl BitPack for (U1, U9)

type Packed = U10

fn pack(self) -> <(U1, U9) as BitPack>::Packed

fn unpack(packed: <(U1, U9) as BitPack>::Packed) -> (U1, U9)

impl BitPack for (U7, U18)

type Packed = U25

fn pack(self) -> <(U7, U18) as BitPack>::Packed

fn unpack(packed: <(U7, U18) as BitPack>::Packed) -> (U7, U18)

impl BitPack for (u8, U54)

type Packed = U62

fn pack(self) -> <(u8, U54) as BitPack>::Packed

fn unpack(packed: <(u8, U54) as BitPack>::Packed) -> (u8, U54)

impl BitPack for (U12, U22)

type Packed = U34

fn pack(self) -> <(U12, U22) as BitPack>::Packed

fn unpack(packed: <(U12, U22) as BitPack>::Packed) -> (U12, U22)

impl BitPack for (U25, U39)

type Packed = u64

fn pack(self) -> <(U25, U39) as BitPack>::Packed

fn unpack(packed: <(U25, U39) as BitPack>::Packed) -> (U25, U39)

impl BitPack for (U15, U36)

type Packed = U51

fn pack(self) -> <(U15, U36) as BitPack>::Packed

fn unpack(packed: <(U15, U36) as BitPack>::Packed) -> (U15, U36)

impl BitPack for (u16, U45)

type Packed = U61

fn pack(self) -> <(u16, U45) as BitPack>::Packed

fn unpack(packed: <(u16, U45) as BitPack>::Packed) -> (u16, U45)

impl BitPack for (U29, u32)

type Packed = U61

fn pack(self) -> <(U29, u32) as BitPack>::Packed

fn unpack(packed: <(U29, u32) as BitPack>::Packed) -> (U29, u32)

impl BitPack for (U43, U18)

type Packed = U61

fn pack(self) -> <(U43, U18) as BitPack>::Packed

fn unpack(packed: <(U43, U18) as BitPack>::Packed) -> (U43, U18)

impl BitPack for (U2, U53)

type Packed = U55

fn pack(self) -> <(U2, U53) as BitPack>::Packed

fn unpack(packed: <(U2, U53) as BitPack>::Packed) -> (U2, U53)

impl BitPack for (U51, U6)

type Packed = U57

fn pack(self) -> <(U51, U6) as BitPack>::Packed

fn unpack(packed: <(U51, U6) as BitPack>::Packed) -> (U51, U6)

impl BitPack for (U34, U7)

type Packed = U41

fn pack(self) -> <(U34, U7) as BitPack>::Packed

fn unpack(packed: <(U34, U7) as BitPack>::Packed) -> (U34, U7)

impl BitPack for (U44, U15)

type Packed = U59

fn pack(self) -> <(U44, U15) as BitPack>::Packed

fn unpack(packed: <(U44, U15) as BitPack>::Packed) -> (U44, U15)

impl BitPack for (u8, U30)

type Packed = U38

fn pack(self) -> <(u8, U30) as BitPack>::Packed

fn unpack(packed: <(u8, U30) as BitPack>::Packed) -> (u8, U30)

impl BitPack for (U25, U26)

type Packed = U51

fn pack(self) -> <(U25, U26) as BitPack>::Packed

fn unpack(packed: <(U25, U26) as BitPack>::Packed) -> (U25, U26)

impl BitPack for (U9, U23)

type Packed = u32

fn pack(self) -> <(U9, U23) as BitPack>::Packed

fn unpack(packed: <(U9, U23) as BitPack>::Packed) -> (U9, U23)

impl BitPack for (U30, U20)

type Packed = U50

fn pack(self) -> <(U30, U20) as BitPack>::Packed

fn unpack(packed: <(U30, U20) as BitPack>::Packed) -> (U30, U20)

impl BitPack for (U47, U17)

type Packed = u64

fn pack(self) -> <(U47, U17) as BitPack>::Packed

fn unpack(packed: <(U47, U17) as BitPack>::Packed) -> (U47, U17)

impl BitPack for (U7, U41)

type Packed = U48

fn pack(self) -> <(U7, U41) as BitPack>::Packed

fn unpack(packed: <(U7, U41) as BitPack>::Packed) -> (U7, U41)

impl BitPack for (U2, U33)

type Packed = U35

fn pack(self) -> <(U2, U33) as BitPack>::Packed

fn unpack(packed: <(U2, U33) as BitPack>::Packed) -> (U2, U33)

impl BitPack for (U56, u8)

type Packed = u64

fn pack(self) -> <(U56, u8) as BitPack>::Packed

fn unpack(packed: <(U56, u8) as BitPack>::Packed) -> (U56, u8)

impl<T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T54, <(T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T54, <(T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U2, U5)

type Packed = U7

fn pack(self) -> <(U2, U5) as BitPack>::Packed

fn unpack(packed: <(U2, U5) as BitPack>::Packed) -> (U2, U5)

impl BitPack for (U46, U1)

type Packed = U47

fn pack(self) -> <(U46, U1) as BitPack>::Packed

fn unpack(packed: <(U46, U1) as BitPack>::Packed) -> (U46, U1)

impl BitPack for (U5, U33)

type Packed = U38

fn pack(self) -> <(U5, U33) as BitPack>::Packed

fn unpack(packed: <(U5, U33) as BitPack>::Packed) -> (U5, U33)

impl BitPack for (U30, U18)

type Packed = U48

fn pack(self) -> <(U30, U18) as BitPack>::Packed

fn unpack(packed: <(U30, U18) as BitPack>::Packed) -> (U30, U18)

impl BitPack for (U38, U3)

type Packed = U41

fn pack(self) -> <(U38, U3) as BitPack>::Packed

fn unpack(packed: <(U38, U3) as BitPack>::Packed) -> (U38, U3)

impl BitPack for (U20, U27)

type Packed = U47

fn pack(self) -> <(U20, U27) as BitPack>::Packed

fn unpack(packed: <(U20, U27) as BitPack>::Packed) -> (U20, U27)

impl BitPack for (U37, U5)

type Packed = U42

fn pack(self) -> <(U37, U5) as BitPack>::Packed

fn unpack(packed: <(U37, U5) as BitPack>::Packed) -> (U37, U5)

impl BitPack for (U61, U2)

type Packed = U63

fn pack(self) -> <(U61, U2) as BitPack>::Packed

fn unpack(packed: <(U61, U2) as BitPack>::Packed) -> (U61, U2)

impl BitPack for (U26, U20)

type Packed = U46

fn pack(self) -> <(U26, U20) as BitPack>::Packed

fn unpack(packed: <(U26, U20) as BitPack>::Packed) -> (U26, U20)

impl BitPack for (U12, U40)

type Packed = U52

fn pack(self) -> <(U12, U40) as BitPack>::Packed

fn unpack(packed: <(U12, U40) as BitPack>::Packed) -> (U12, U40)

impl BitPack for (U40, U23)

type Packed = U63

fn pack(self) -> <(U40, U23) as BitPack>::Packed

fn unpack(packed: <(U40, U23) as BitPack>::Packed) -> (U40, U23)

impl BitPack for (U1, U61)

type Packed = U62

fn pack(self) -> <(U1, U61) as BitPack>::Packed

fn unpack(packed: <(U1, U61) as BitPack>::Packed) -> (U1, U61)

impl BitPack for (U44, u8)

type Packed = U52

fn pack(self) -> <(U44, u8) as BitPack>::Packed

fn unpack(packed: <(U44, u8) as BitPack>::Packed) -> (U44, u8)

impl BitPack for (U17, U34)

type Packed = U51

fn pack(self) -> <(U17, U34) as BitPack>::Packed

fn unpack(packed: <(U17, U34) as BitPack>::Packed) -> (U17, U34)

impl BitPack for (U27, U37)

type Packed = u64

fn pack(self) -> <(U27, U37) as BitPack>::Packed

fn unpack(packed: <(U27, U37) as BitPack>::Packed) -> (U27, U37)

impl BitPack for (U18, U40)

type Packed = U58

fn pack(self) -> <(U18, U40) as BitPack>::Packed

fn unpack(packed: <(U18, U40) as BitPack>::Packed) -> (U18, U40)

impl<T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T41, <(T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T41, <(T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U15, U10)

type Packed = U25

fn pack(self) -> <(U15, U10) as BitPack>::Packed

fn unpack(packed: <(U15, U10) as BitPack>::Packed) -> (U15, U10)

impl BitPack for (U27, U33)

type Packed = U60

fn pack(self) -> <(U27, U33) as BitPack>::Packed

fn unpack(packed: <(U27, U33) as BitPack>::Packed) -> (U27, U33)

impl BitPack for (u32, u8)

type Packed = U40

fn pack(self) -> <(u32, u8) as BitPack>::Packed

fn unpack(packed: <(u32, u8) as BitPack>::Packed) -> (u32, u8)

impl BitPack for (U6, U9)

type Packed = U15

fn pack(self) -> <(U6, U9) as BitPack>::Packed

fn unpack(packed: <(U6, U9) as BitPack>::Packed) -> (U6, U9)

impl BitPack for (U25, u32)

type Packed = U57

fn pack(self) -> <(U25, u32) as BitPack>::Packed

fn unpack(packed: <(U25, u32) as BitPack>::Packed) -> (U25, u32)

impl BitPack for (U39, U17)

type Packed = U56

fn pack(self) -> <(U39, U17) as BitPack>::Packed

fn unpack(packed: <(U39, U17) as BitPack>::Packed) -> (U39, U17)

impl BitPack for (u16, U25)

type Packed = U41

fn pack(self) -> <(u16, U25) as BitPack>::Packed

fn unpack(packed: <(u16, U25) as BitPack>::Packed) -> (u16, U25)

impl BitPack for (U9, U26)

type Packed = U35

fn pack(self) -> <(U9, U26) as BitPack>::Packed

fn unpack(packed: <(U9, U26) as BitPack>::Packed) -> (U9, U26)

impl BitPack for (U27, U25)

type Packed = U52

fn pack(self) -> <(U27, U25) as BitPack>::Packed

fn unpack(packed: <(U27, U25) as BitPack>::Packed) -> (U27, U25)

impl BitPack for (U6, U56)

type Packed = U62

fn pack(self) -> <(U6, U56) as BitPack>::Packed

fn unpack(packed: <(U6, U56) as BitPack>::Packed) -> (U6, U56)

impl BitPack for (U22, U11)

type Packed = U33

fn pack(self) -> <(U22, U11) as BitPack>::Packed

fn unpack(packed: <(U22, U11) as BitPack>::Packed) -> (U22, U11)

impl BitPack for (U6, U51)

type Packed = U57

fn pack(self) -> <(U6, U51) as BitPack>::Packed

fn unpack(packed: <(U6, U51) as BitPack>::Packed) -> (U6, U51)

impl BitPack for (U4, U4)

type Packed = u8

fn pack(self) -> <(U4, U4) as BitPack>::Packed

fn unpack(packed: <(U4, U4) as BitPack>::Packed) -> (U4, U4)

impl BitPack for (U17, U45)

type Packed = U62

fn pack(self) -> <(U17, U45) as BitPack>::Packed

fn unpack(packed: <(U17, U45) as BitPack>::Packed) -> (U17, U45)

impl BitPack for (u32, U1)

type Packed = U33

fn pack(self) -> <(u32, U1) as BitPack>::Packed

fn unpack(packed: <(u32, U1) as BitPack>::Packed) -> (u32, U1)

impl BitPack for (U25, U37)

type Packed = U62

fn pack(self) -> <(U25, U37) as BitPack>::Packed

fn unpack(packed: <(U25, U37) as BitPack>::Packed) -> (U25, U37)

impl BitPack for (U10, U54)

type Packed = u64

fn pack(self) -> <(U10, U54) as BitPack>::Packed

fn unpack(packed: <(U10, U54) as BitPack>::Packed) -> (U10, U54)

impl BitPack for (U9, U33)

type Packed = U42

fn pack(self) -> <(U9, U33) as BitPack>::Packed

fn unpack(packed: <(U9, U33) as BitPack>::Packed) -> (U9, U33)

impl BitPack for (U5, U58)

type Packed = U63

fn pack(self) -> <(U5, U58) as BitPack>::Packed

fn unpack(packed: <(U5, U58) as BitPack>::Packed) -> (U5, U58)

impl BitPack for (U13, U42)

type Packed = U55

fn pack(self) -> <(U13, U42) as BitPack>::Packed

fn unpack(packed: <(U13, U42) as BitPack>::Packed) -> (U13, U42)

impl BitPack for (U29, U19)

type Packed = U48

fn pack(self) -> <(U29, U19) as BitPack>::Packed

fn unpack(packed: <(U29, U19) as BitPack>::Packed) -> (U29, U19)

impl BitPack for (U26, U38)

type Packed = u64

fn pack(self) -> <(U26, U38) as BitPack>::Packed

fn unpack(packed: <(U26, U38) as BitPack>::Packed) -> (U26, U38)

impl BitPack for (u16, U46)

type Packed = U62

fn pack(self) -> <(u16, U46) as BitPack>::Packed

fn unpack(packed: <(u16, U46) as BitPack>::Packed) -> (u16, U46)

impl BitPack for (U6, U21)

type Packed = U27

fn pack(self) -> <(U6, U21) as BitPack>::Packed

fn unpack(packed: <(U6, U21) as BitPack>::Packed) -> (U6, U21)

impl BitPack for (U26, U18)

type Packed = U44

fn pack(self) -> <(U26, U18) as BitPack>::Packed

fn unpack(packed: <(U26, U18) as BitPack>::Packed) -> (U26, U18)

impl BitPack for (U29, U7)

type Packed = U36

fn pack(self) -> <(U29, U7) as BitPack>::Packed

fn unpack(packed: <(U29, U7) as BitPack>::Packed) -> (U29, U7)

impl BitPack for (U18, U39)

type Packed = U57

fn pack(self) -> <(U18, U39) as BitPack>::Packed

fn unpack(packed: <(U18, U39) as BitPack>::Packed) -> (U18, U39)

impl BitPack for (U19, U29)

type Packed = U48

fn pack(self) -> <(U19, U29) as BitPack>::Packed

fn unpack(packed: <(U19, U29) as BitPack>::Packed) -> (U19, U29)

impl BitPack for (U23, U18)

type Packed = U41

fn pack(self) -> <(U23, U18) as BitPack>::Packed

fn unpack(packed: <(U23, U18) as BitPack>::Packed) -> (U23, U18)

impl BitPack for (U1, U38)

type Packed = U39

fn pack(self) -> <(U1, U38) as BitPack>::Packed

fn unpack(packed: <(U1, U38) as BitPack>::Packed) -> (U1, U38)

impl BitPack for (U27, U31)

type Packed = U58

fn pack(self) -> <(U27, U31) as BitPack>::Packed

fn unpack(packed: <(U27, U31) as BitPack>::Packed) -> (U27, U31)

impl BitPack for (U25, U25)

type Packed = U50

fn pack(self) -> <(U25, U25) as BitPack>::Packed

fn unpack(packed: <(U25, U25) as BitPack>::Packed) -> (U25, U25)

impl BitPack for (U7, U52)

type Packed = U59

fn pack(self) -> <(U7, U52) as BitPack>::Packed

fn unpack(packed: <(U7, U52) as BitPack>::Packed) -> (U7, U52)

impl BitPack for (U5, U5)

type Packed = U10

fn pack(self) -> <(U5, U5) as BitPack>::Packed

fn unpack(packed: <(U5, U5) as BitPack>::Packed) -> (U5, U5)

impl BitPack for (U3, U9)

type Packed = U12

fn pack(self) -> <(U3, U9) as BitPack>::Packed

fn unpack(packed: <(U3, U9) as BitPack>::Packed) -> (U3, U9)

impl BitPack for (U3, U17)

type Packed = U20

fn pack(self) -> <(U3, U17) as BitPack>::Packed

fn unpack(packed: <(U3, U17) as BitPack>::Packed) -> (U3, U17)

impl BitPack for (U26, u8)

type Packed = U34

fn pack(self) -> <(U26, u8) as BitPack>::Packed

fn unpack(packed: <(U26, u8) as BitPack>::Packed) -> (U26, u8)

impl<T59, T60, T61, T62, T63, T64> BitPack for (T59, T60, T61, T62, T63, T64)where
    (T60, T61, T62, T63, T64): BitPack,
    (T59, <(T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T59, <(T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(self) -> <(T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T59, T60, T61, T62, T63, T64)

impl BitPack for (U40, U13)

type Packed = U53

fn pack(self) -> <(U40, U13) as BitPack>::Packed

fn unpack(packed: <(U40, U13) as BitPack>::Packed) -> (U40, U13)

impl BitPack for (U36, U12)

type Packed = U48

fn pack(self) -> <(U36, U12) as BitPack>::Packed

fn unpack(packed: <(U36, U12) as BitPack>::Packed) -> (U36, U12)

impl BitPack for (U5, U7)

type Packed = U12

fn pack(self) -> <(U5, U7) as BitPack>::Packed

fn unpack(packed: <(U5, U7) as BitPack>::Packed) -> (U5, U7)

impl BitPack for (U29, U28)

type Packed = U57

fn pack(self) -> <(U29, U28) as BitPack>::Packed

fn unpack(packed: <(U29, U28) as BitPack>::Packed) -> (U29, U28)

impl BitPack for (U23, U34)

type Packed = U57

fn pack(self) -> <(U23, U34) as BitPack>::Packed

fn unpack(packed: <(U23, U34) as BitPack>::Packed) -> (U23, U34)

impl BitPack for (U29, u16)

type Packed = U45

fn pack(self) -> <(U29, u16) as BitPack>::Packed

fn unpack(packed: <(U29, u16) as BitPack>::Packed) -> (U29, u16)

impl BitPack for (U27, U3)

type Packed = U30

fn pack(self) -> <(U27, U3) as BitPack>::Packed

fn unpack(packed: <(U27, U3) as BitPack>::Packed) -> (U27, U3)

impl BitPack for (U13, U33)

type Packed = U46

fn pack(self) -> <(U13, U33) as BitPack>::Packed

fn unpack(packed: <(U13, U33) as BitPack>::Packed) -> (U13, U33)

impl BitPack for (U2, U36)

type Packed = U38

fn pack(self) -> <(U2, U36) as BitPack>::Packed

fn unpack(packed: <(U2, U36) as BitPack>::Packed) -> (U2, U36)

impl BitPack for (U29, U15)

type Packed = U44

fn pack(self) -> <(U29, U15) as BitPack>::Packed

fn unpack(packed: <(U29, U15) as BitPack>::Packed) -> (U29, U15)

impl BitPack for (U15, U7)

type Packed = U22

fn pack(self) -> <(U15, U7) as BitPack>::Packed

fn unpack(packed: <(U15, U7) as BitPack>::Packed) -> (U15, U7)

impl BitPack for (U46, U15)

type Packed = U61

fn pack(self) -> <(U46, U15) as BitPack>::Packed

fn unpack(packed: <(U46, U15) as BitPack>::Packed) -> (U46, U15)

impl BitPack for (u32, U3)

type Packed = U35

fn pack(self) -> <(u32, U3) as BitPack>::Packed

fn unpack(packed: <(u32, U3) as BitPack>::Packed) -> (u32, U3)

impl BitPack for (u16, U13)

type Packed = U29

fn pack(self) -> <(u16, U13) as BitPack>::Packed

fn unpack(packed: <(u16, U13) as BitPack>::Packed) -> (u16, U13)

impl BitPack for (U22, U24)

type Packed = U46

fn pack(self) -> <(U22, U24) as BitPack>::Packed

fn unpack(packed: <(U22, U24) as BitPack>::Packed) -> (U22, U24)

impl BitPack for (U27, U19)

type Packed = U46

fn pack(self) -> <(U27, U19) as BitPack>::Packed

fn unpack(packed: <(U27, U19) as BitPack>::Packed) -> (U27, U19)

impl BitPack for (U42, U12)

type Packed = U54

fn pack(self) -> <(U42, U12) as BitPack>::Packed

fn unpack(packed: <(U42, U12) as BitPack>::Packed) -> (U42, U12)

impl BitPack for (U31, U4)

type Packed = U35

fn pack(self) -> <(U31, U4) as BitPack>::Packed

fn unpack(packed: <(U31, U4) as BitPack>::Packed) -> (U31, U4)

impl BitPack for (U5, U50)

type Packed = U55

fn pack(self) -> <(U5, U50) as BitPack>::Packed

fn unpack(packed: <(U5, U50) as BitPack>::Packed) -> (U5, U50)

impl BitPack for (U9, U22)

type Packed = U31

fn pack(self) -> <(U9, U22) as BitPack>::Packed

fn unpack(packed: <(U9, U22) as BitPack>::Packed) -> (U9, U22)

impl BitPack for (U19, U28)

type Packed = U47

fn pack(self) -> <(U19, U28) as BitPack>::Packed

fn unpack(packed: <(U19, U28) as BitPack>::Packed) -> (U19, U28)

impl BitPack for (U56, U6)

type Packed = U62

fn pack(self) -> <(U56, U6) as BitPack>::Packed

fn unpack(packed: <(U56, U6) as BitPack>::Packed) -> (U56, U6)

impl BitPack for (U13, U12)

type Packed = U25

fn pack(self) -> <(U13, U12) as BitPack>::Packed

fn unpack(packed: <(U13, U12) as BitPack>::Packed) -> (U13, U12)

impl BitPack for (U2, U30)

type Packed = u32

fn pack(self) -> <(U2, U30) as BitPack>::Packed

fn unpack(packed: <(U2, U30) as BitPack>::Packed) -> (U2, U30)

impl BitPack for (U21, U18)

type Packed = U39

fn pack(self) -> <(U21, U18) as BitPack>::Packed

fn unpack(packed: <(U21, U18) as BitPack>::Packed) -> (U21, U18)

impl BitPack for (U20, U11)

type Packed = U31

fn pack(self) -> <(U20, U11) as BitPack>::Packed

fn unpack(packed: <(U20, U11) as BitPack>::Packed) -> (U20, U11)

impl BitPack for (U6, u16)

type Packed = U22

fn pack(self) -> <(U6, u16) as BitPack>::Packed

fn unpack(packed: <(U6, u16) as BitPack>::Packed) -> (U6, u16)

impl BitPack for (U4, u32)

type Packed = U36

fn pack(self) -> <(U4, u32) as BitPack>::Packed

fn unpack(packed: <(U4, u32) as BitPack>::Packed) -> (U4, u32)

impl BitPack for (U24, U18)

type Packed = U42

fn pack(self) -> <(U24, U18) as BitPack>::Packed

fn unpack(packed: <(U24, U18) as BitPack>::Packed) -> (U24, U18)

impl BitPack for (U14, U1)

type Packed = U15

fn pack(self) -> <(U14, U1) as BitPack>::Packed

fn unpack(packed: <(U14, U1) as BitPack>::Packed) -> (U14, U1)

impl BitPack for (U51, U7)

type Packed = U58

fn pack(self) -> <(U51, U7) as BitPack>::Packed

fn unpack(packed: <(U51, U7) as BitPack>::Packed) -> (U51, U7)

impl BitPack for (U26, u16)

type Packed = U42

fn pack(self) -> <(U26, u16) as BitPack>::Packed

fn unpack(packed: <(U26, u16) as BitPack>::Packed) -> (U26, u16)

impl BitPack for (U11, U30)

type Packed = U41

fn pack(self) -> <(U11, U30) as BitPack>::Packed

fn unpack(packed: <(U11, U30) as BitPack>::Packed) -> (U11, U30)

impl BitPack for (U1, U40)

type Packed = U41

fn pack(self) -> <(U1, U40) as BitPack>::Packed

fn unpack(packed: <(U1, U40) as BitPack>::Packed) -> (U1, U40)

impl BitPack for (U1, U10)

type Packed = U11

fn pack(self) -> <(U1, U10) as BitPack>::Packed

fn unpack(packed: <(U1, U10) as BitPack>::Packed) -> (U1, U10)

impl BitPack for (u8, U23)

type Packed = U31

fn pack(self) -> <(u8, U23) as BitPack>::Packed

fn unpack(packed: <(u8, U23) as BitPack>::Packed) -> (u8, U23)

impl BitPack for (U37, U12)

type Packed = U49

fn pack(self) -> <(U37, U12) as BitPack>::Packed

fn unpack(packed: <(U37, U12) as BitPack>::Packed) -> (U37, U12)

impl BitPack for (U11, U6)

type Packed = U17

fn pack(self) -> <(U11, U6) as BitPack>::Packed

fn unpack(packed: <(U11, U6) as BitPack>::Packed) -> (U11, U6)

impl BitPack for (U11, U45)

type Packed = U56

fn pack(self) -> <(U11, U45) as BitPack>::Packed

fn unpack(packed: <(U11, U45) as BitPack>::Packed) -> (U11, U45)

impl BitPack for (U42, u16)

type Packed = U58

fn pack(self) -> <(U42, u16) as BitPack>::Packed

fn unpack(packed: <(U42, u16) as BitPack>::Packed) -> (U42, u16)

impl BitPack for (U21, U10)

type Packed = U31

fn pack(self) -> <(U21, U10) as BitPack>::Packed

fn unpack(packed: <(U21, U10) as BitPack>::Packed) -> (U21, U10)

impl BitPack for (U25, U38)

type Packed = U63

fn pack(self) -> <(U25, U38) as BitPack>::Packed

fn unpack(packed: <(U25, U38) as BitPack>::Packed) -> (U25, U38)

impl BitPack for (U10, U39)

type Packed = U49

fn pack(self) -> <(U10, U39) as BitPack>::Packed

fn unpack(packed: <(U10, U39) as BitPack>::Packed) -> (U10, U39)

impl BitPack for (U35, U1)

type Packed = U36

fn pack(self) -> <(U35, U1) as BitPack>::Packed

fn unpack(packed: <(U35, U1) as BitPack>::Packed) -> (U35, U1)

impl BitPack for (U7, U9)

type Packed = u16

fn pack(self) -> <(U7, U9) as BitPack>::Packed

fn unpack(packed: <(U7, U9) as BitPack>::Packed) -> (U7, U9)

impl BitPack for (U12, U50)

type Packed = U62

fn pack(self) -> <(U12, U50) as BitPack>::Packed

fn unpack(packed: <(U12, U50) as BitPack>::Packed) -> (U12, U50)

impl BitPack for (U47, U11)

type Packed = U58

fn pack(self) -> <(U47, U11) as BitPack>::Packed

fn unpack(packed: <(U47, U11) as BitPack>::Packed) -> (U47, U11)

impl BitPack for (U5, U37)

type Packed = U42

fn pack(self) -> <(U5, U37) as BitPack>::Packed

fn unpack(packed: <(U5, U37) as BitPack>::Packed) -> (U5, U37)

impl BitPack for (U39, U6)

type Packed = U45

fn pack(self) -> <(U39, U6) as BitPack>::Packed

fn unpack(packed: <(U39, U6) as BitPack>::Packed) -> (U39, U6)

impl BitPack for (U14, U28)

type Packed = U42

fn pack(self) -> <(U14, U28) as BitPack>::Packed

fn unpack(packed: <(U14, U28) as BitPack>::Packed) -> (U14, U28)

impl BitPack for (U15, U39)

type Packed = U54

fn pack(self) -> <(U15, U39) as BitPack>::Packed

fn unpack(packed: <(U15, U39) as BitPack>::Packed) -> (U15, U39)

impl BitPack for (U3, U14)

type Packed = U17

fn pack(self) -> <(U3, U14) as BitPack>::Packed

fn unpack(packed: <(U3, U14) as BitPack>::Packed) -> (U3, U14)

impl BitPack for (U22, U33)

type Packed = U55

fn pack(self) -> <(U22, U33) as BitPack>::Packed

fn unpack(packed: <(U22, U33) as BitPack>::Packed) -> (U22, U33)

impl BitPack for (U27, U18)

type Packed = U45

fn pack(self) -> <(U27, U18) as BitPack>::Packed

fn unpack(packed: <(U27, U18) as BitPack>::Packed) -> (U27, U18)

impl BitPack for (U36, U17)

type Packed = U53

fn pack(self) -> <(U36, U17) as BitPack>::Packed

fn unpack(packed: <(U36, U17) as BitPack>::Packed) -> (U36, U17)

impl BitPack for (u8, U48)

type Packed = U56

fn pack(self) -> <(u8, U48) as BitPack>::Packed

fn unpack(packed: <(u8, U48) as BitPack>::Packed) -> (u8, U48)

impl BitPack for (U37, U24)

type Packed = U61

fn pack(self) -> <(U37, U24) as BitPack>::Packed

fn unpack(packed: <(U37, U24) as BitPack>::Packed) -> (U37, U24)

impl BitPack for (U34, U3)

type Packed = U37

fn pack(self) -> <(U34, U3) as BitPack>::Packed

fn unpack(packed: <(U34, U3) as BitPack>::Packed) -> (U34, U3)

impl BitPack for (U31, U28)

type Packed = U59

fn pack(self) -> <(U31, U28) as BitPack>::Packed

fn unpack(packed: <(U31, U28) as BitPack>::Packed) -> (U31, U28)

impl BitPack for (U49, U9)

type Packed = U58

fn pack(self) -> <(U49, U9) as BitPack>::Packed

fn unpack(packed: <(U49, U9) as BitPack>::Packed) -> (U49, U9)

impl BitPack for (u32, U21)

type Packed = U53

fn pack(self) -> <(u32, U21) as BitPack>::Packed

fn unpack(packed: <(u32, U21) as BitPack>::Packed) -> (u32, U21)

impl<T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T42, <(T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T42, <(T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U25, U33)

type Packed = U58

fn pack(self) -> <(U25, U33) as BitPack>::Packed

fn unpack(packed: <(U25, U33) as BitPack>::Packed) -> (U25, U33)

impl BitPack for (u8, U11)

type Packed = U19

fn pack(self) -> <(u8, U11) as BitPack>::Packed

fn unpack(packed: <(u8, U11) as BitPack>::Packed) -> (u8, U11)

impl BitPack for (U46, U3)

type Packed = U49

fn pack(self) -> <(U46, U3) as BitPack>::Packed

fn unpack(packed: <(U46, U3) as BitPack>::Packed) -> (U46, U3)

impl BitPack for (U20, u8)

type Packed = U28

fn pack(self) -> <(U20, u8) as BitPack>::Packed

fn unpack(packed: <(U20, u8) as BitPack>::Packed) -> (U20, u8)

impl BitPack for (U15, U21)

type Packed = U36

fn pack(self) -> <(U15, U21) as BitPack>::Packed

fn unpack(packed: <(U15, U21) as BitPack>::Packed) -> (U15, U21)

impl BitPack for (U56, U3)

type Packed = U59

fn pack(self) -> <(U56, U3) as BitPack>::Packed

fn unpack(packed: <(U56, U3) as BitPack>::Packed) -> (U56, U3)

impl BitPack for (U10, U38)

type Packed = U48

fn pack(self) -> <(U10, U38) as BitPack>::Packed

fn unpack(packed: <(U10, U38) as BitPack>::Packed) -> (U10, U38)

impl BitPack for (U19, U45)

type Packed = u64

fn pack(self) -> <(U19, U45) as BitPack>::Packed

fn unpack(packed: <(U19, U45) as BitPack>::Packed) -> (U19, U45)

impl<T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T51, <(T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T51, <(T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U14, U36)

type Packed = U50

fn pack(self) -> <(U14, U36) as BitPack>::Packed

fn unpack(packed: <(U14, U36) as BitPack>::Packed) -> (U14, U36)

impl BitPack for (U35, U23)

type Packed = U58

fn pack(self) -> <(U35, U23) as BitPack>::Packed

fn unpack(packed: <(U35, U23) as BitPack>::Packed) -> (U35, U23)

impl BitPack for (U42, U21)

type Packed = U63

fn pack(self) -> <(U42, U21) as BitPack>::Packed

fn unpack(packed: <(U42, U21) as BitPack>::Packed) -> (U42, U21)

impl BitPack for (U1, U28)

type Packed = U29

fn pack(self) -> <(U1, U28) as BitPack>::Packed

fn unpack(packed: <(U1, U28) as BitPack>::Packed) -> (U1, U28)

impl BitPack for (U19, U42)

type Packed = U61

fn pack(self) -> <(U19, U42) as BitPack>::Packed

fn unpack(packed: <(U19, U42) as BitPack>::Packed) -> (U19, U42)

impl BitPack for (U1, U35)

type Packed = U36

fn pack(self) -> <(U1, U35) as BitPack>::Packed

fn unpack(packed: <(U1, U35) as BitPack>::Packed) -> (U1, U35)

impl BitPack for (U10, U25)

type Packed = U35

fn pack(self) -> <(U10, U25) as BitPack>::Packed

fn unpack(packed: <(U10, U25) as BitPack>::Packed) -> (U10, U25)

impl BitPack for (U37, U15)

type Packed = U52

fn pack(self) -> <(U37, U15) as BitPack>::Packed

fn unpack(packed: <(U37, U15) as BitPack>::Packed) -> (U37, U15)

impl BitPack for (U3, U2)

type Packed = U5

fn pack(self) -> <(U3, U2) as BitPack>::Packed

fn unpack(packed: <(U3, U2) as BitPack>::Packed) -> (U3, U2)

impl BitPack for (U14, U37)

type Packed = U51

fn pack(self) -> <(U14, U37) as BitPack>::Packed

fn unpack(packed: <(U14, U37) as BitPack>::Packed) -> (U14, U37)

impl BitPack for (U36, U5)

type Packed = U41

fn pack(self) -> <(U36, U5) as BitPack>::Packed

fn unpack(packed: <(U36, U5) as BitPack>::Packed) -> (U36, U5)

impl BitPack for (U48, U12)

type Packed = U60

fn pack(self) -> <(U48, U12) as BitPack>::Packed

fn unpack(packed: <(U48, U12) as BitPack>::Packed) -> (U48, U12)

impl BitPack for (u16, U33)

type Packed = U49

fn pack(self) -> <(u16, U33) as BitPack>::Packed

fn unpack(packed: <(u16, U33) as BitPack>::Packed) -> (u16, U33)

impl BitPack for (u16, u32)

type Packed = U48

fn pack(self) -> <(u16, u32) as BitPack>::Packed

fn unpack(packed: <(u16, u32) as BitPack>::Packed) -> (u16, u32)

impl BitPack for (U7, u8)

type Packed = U15

fn pack(self) -> <(U7, u8) as BitPack>::Packed

fn unpack(packed: <(U7, u8) as BitPack>::Packed) -> (U7, u8)

impl BitPack for (U9, U39)

type Packed = U48

fn pack(self) -> <(U9, U39) as BitPack>::Packed

fn unpack(packed: <(U9, U39) as BitPack>::Packed) -> (U9, U39)

impl BitPack for (U29, U23)

type Packed = U52

fn pack(self) -> <(U29, U23) as BitPack>::Packed

fn unpack(packed: <(U29, U23) as BitPack>::Packed) -> (U29, U23)

impl BitPack for (U13, U28)

type Packed = U41

fn pack(self) -> <(U13, U28) as BitPack>::Packed

fn unpack(packed: <(U13, U28) as BitPack>::Packed) -> (U13, U28)

impl BitPack for (U57, U5)

type Packed = U62

fn pack(self) -> <(U57, U5) as BitPack>::Packed

fn unpack(packed: <(U57, U5) as BitPack>::Packed) -> (U57, U5)

impl BitPack for (U33, U17)

type Packed = U50

fn pack(self) -> <(U33, U17) as BitPack>::Packed

fn unpack(packed: <(U33, U17) as BitPack>::Packed) -> (U33, U17)

impl BitPack for (U21, U20)

type Packed = U41

fn pack(self) -> <(U21, U20) as BitPack>::Packed

fn unpack(packed: <(U21, U20) as BitPack>::Packed) -> (U21, U20)

impl BitPack for (U10, U48)

type Packed = U58

fn pack(self) -> <(U10, U48) as BitPack>::Packed

fn unpack(packed: <(U10, U48) as BitPack>::Packed) -> (U10, U48)

impl BitPack for (U5, U31)

type Packed = U36

fn pack(self) -> <(U5, U31) as BitPack>::Packed

fn unpack(packed: <(U5, U31) as BitPack>::Packed) -> (U5, U31)

impl BitPack for (U11, U44)

type Packed = U55

fn pack(self) -> <(U11, U44) as BitPack>::Packed

fn unpack(packed: <(U11, U44) as BitPack>::Packed) -> (U11, U44)

impl BitPack for (U3, U33)

type Packed = U36

fn pack(self) -> <(U3, U33) as BitPack>::Packed

fn unpack(packed: <(U3, U33) as BitPack>::Packed) -> (U3, U33)

impl BitPack for (u32, U9)

type Packed = U41

fn pack(self) -> <(u32, U9) as BitPack>::Packed

fn unpack(packed: <(u32, U9) as BitPack>::Packed) -> (u32, U9)

impl BitPack for (U36, U22)

type Packed = U58

fn pack(self) -> <(U36, U22) as BitPack>::Packed

fn unpack(packed: <(U36, U22) as BitPack>::Packed) -> (U36, U22)

impl BitPack for (u8, U29)

type Packed = U37

fn pack(self) -> <(u8, U29) as BitPack>::Packed

fn unpack(packed: <(u8, U29) as BitPack>::Packed) -> (u8, U29)

impl BitPack for (U20, u16)

type Packed = U36

fn pack(self) -> <(U20, u16) as BitPack>::Packed

fn unpack(packed: <(U20, u16) as BitPack>::Packed) -> (U20, u16)

impl BitPack for (U33, U19)

type Packed = U52

fn pack(self) -> <(U33, U19) as BitPack>::Packed

fn unpack(packed: <(U33, U19) as BitPack>::Packed) -> (U33, U19)

impl BitPack for (U47, U15)

type Packed = U62

fn pack(self) -> <(U47, U15) as BitPack>::Packed

fn unpack(packed: <(U47, U15) as BitPack>::Packed) -> (U47, U15)

impl BitPack for (U47, U6)

type Packed = U53

fn pack(self) -> <(U47, U6) as BitPack>::Packed

fn unpack(packed: <(U47, U6) as BitPack>::Packed) -> (U47, U6)

impl BitPack for (U5, U29)

type Packed = U34

fn pack(self) -> <(U5, U29) as BitPack>::Packed

fn unpack(packed: <(U5, U29) as BitPack>::Packed) -> (U5, U29)

impl BitPack for (U15, U44)

type Packed = U59

fn pack(self) -> <(U15, U44) as BitPack>::Packed

fn unpack(packed: <(U15, U44) as BitPack>::Packed) -> (U15, U44)

impl BitPack for (U10, U6)

type Packed = u16

fn pack(self) -> <(U10, U6) as BitPack>::Packed

fn unpack(packed: <(U10, U6) as BitPack>::Packed) -> (U10, U6)

impl BitPack for (U13, U37)

type Packed = U50

fn pack(self) -> <(U13, U37) as BitPack>::Packed

fn unpack(packed: <(U13, U37) as BitPack>::Packed) -> (U13, U37)

impl BitPack for (U7, U3)

type Packed = U10

fn pack(self) -> <(U7, U3) as BitPack>::Packed

fn unpack(packed: <(U7, U3) as BitPack>::Packed) -> (U7, U3)

impl BitPack for (U7, U23)

type Packed = U30

fn pack(self) -> <(U7, U23) as BitPack>::Packed

fn unpack(packed: <(U7, U23) as BitPack>::Packed) -> (U7, U23)

impl BitPack for (U4, U29)

type Packed = U33

fn pack(self) -> <(U4, U29) as BitPack>::Packed

fn unpack(packed: <(U4, U29) as BitPack>::Packed) -> (U4, U29)

impl BitPack for (U48, U7)

type Packed = U55

fn pack(self) -> <(U48, U7) as BitPack>::Packed

fn unpack(packed: <(U48, U7) as BitPack>::Packed) -> (U48, U7)

impl BitPack for (u8, U46)

type Packed = U54

fn pack(self) -> <(u8, U46) as BitPack>::Packed

fn unpack(packed: <(u8, U46) as BitPack>::Packed) -> (u8, U46)

impl BitPack for (U28, U15)

type Packed = U43

fn pack(self) -> <(U28, U15) as BitPack>::Packed

fn unpack(packed: <(U28, U15) as BitPack>::Packed) -> (U28, U15)

impl BitPack for (U13, U27)

type Packed = U40

fn pack(self) -> <(U13, U27) as BitPack>::Packed

fn unpack(packed: <(U13, U27) as BitPack>::Packed) -> (U13, U27)

impl BitPack for (U6, U10)

type Packed = u16

fn pack(self) -> <(U6, U10) as BitPack>::Packed

fn unpack(packed: <(U6, U10) as BitPack>::Packed) -> (U6, U10)

impl BitPack for (U14, U26)

type Packed = U40

fn pack(self) -> <(U14, U26) as BitPack>::Packed

fn unpack(packed: <(U14, U26) as BitPack>::Packed) -> (U14, U26)

impl BitPack for (U24, U36)

type Packed = U60

fn pack(self) -> <(U24, U36) as BitPack>::Packed

fn unpack(packed: <(U24, U36) as BitPack>::Packed) -> (U24, U36)

impl BitPack for (U20, U4)

type Packed = U24

fn pack(self) -> <(U20, U4) as BitPack>::Packed

fn unpack(packed: <(U20, U4) as BitPack>::Packed) -> (U20, U4)

impl BitPack for (U33, U22)

type Packed = U55

fn pack(self) -> <(U33, U22) as BitPack>::Packed

fn unpack(packed: <(U33, U22) as BitPack>::Packed) -> (U33, U22)

impl BitPack for (U14, U50)

type Packed = u64

fn pack(self) -> <(U14, U50) as BitPack>::Packed

fn unpack(packed: <(U14, U50) as BitPack>::Packed) -> (U14, U50)

impl BitPack for (U6, U14)

type Packed = U20

fn pack(self) -> <(U6, U14) as BitPack>::Packed

fn unpack(packed: <(U6, U14) as BitPack>::Packed) -> (U6, U14)

impl BitPack for (U6, U31)

type Packed = U37

fn pack(self) -> <(U6, U31) as BitPack>::Packed

fn unpack(packed: <(U6, U31) as BitPack>::Packed) -> (U6, U31)

impl BitPack for (U56, U5)

type Packed = U61

fn pack(self) -> <(U56, U5) as BitPack>::Packed

fn unpack(packed: <(U56, U5) as BitPack>::Packed) -> (U56, U5)

impl BitPack for (U13, U31)

type Packed = U44

fn pack(self) -> <(U13, U31) as BitPack>::Packed

fn unpack(packed: <(U13, U31) as BitPack>::Packed) -> (U13, U31)

impl BitPack for (U5, U15)

type Packed = U20

fn pack(self) -> <(U5, U15) as BitPack>::Packed

fn unpack(packed: <(U5, U15) as BitPack>::Packed) -> (U5, U15)

impl BitPack for (U61, U3)

type Packed = u64

fn pack(self) -> <(U61, U3) as BitPack>::Packed

fn unpack(packed: <(U61, U3) as BitPack>::Packed) -> (U61, U3)

impl BitPack for (U19, U17)

type Packed = U36

fn pack(self) -> <(U19, U17) as BitPack>::Packed

fn unpack(packed: <(U19, U17) as BitPack>::Packed) -> (U19, U17)

impl BitPack for (U13, U30)

type Packed = U43

fn pack(self) -> <(U13, U30) as BitPack>::Packed

fn unpack(packed: <(U13, U30) as BitPack>::Packed) -> (U13, U30)

impl BitPack for (U38, U23)

type Packed = U61

fn pack(self) -> <(U38, U23) as BitPack>::Packed

fn unpack(packed: <(U38, U23) as BitPack>::Packed) -> (U38, U23)

impl BitPack for (U6, U17)

type Packed = U23

fn pack(self) -> <(U6, U17) as BitPack>::Packed

fn unpack(packed: <(U6, U17) as BitPack>::Packed) -> (U6, U17)

impl BitPack for (U26, U27)

type Packed = U53

fn pack(self) -> <(U26, U27) as BitPack>::Packed

fn unpack(packed: <(U26, U27) as BitPack>::Packed) -> (U26, U27)

impl BitPack for (U12, U10)

type Packed = U22

fn pack(self) -> <(U12, U10) as BitPack>::Packed

fn unpack(packed: <(U12, U10) as BitPack>::Packed) -> (U12, U10)

impl BitPack for (U25, U13)

type Packed = U38

fn pack(self) -> <(U25, U13) as BitPack>::Packed

fn unpack(packed: <(U25, U13) as BitPack>::Packed) -> (U25, U13)

impl BitPack for (U24, U11)

type Packed = U35

fn pack(self) -> <(U24, U11) as BitPack>::Packed

fn unpack(packed: <(U24, U11) as BitPack>::Packed) -> (U24, U11)

impl BitPack for (U21, U6)

type Packed = U27

fn pack(self) -> <(U21, U6) as BitPack>::Packed

fn unpack(packed: <(U21, U6) as BitPack>::Packed) -> (U21, U6)

impl BitPack for (U25, U36)

type Packed = U61

fn pack(self) -> <(U25, U36) as BitPack>::Packed

fn unpack(packed: <(U25, U36) as BitPack>::Packed) -> (U25, U36)

impl BitPack for (U48, U3)

type Packed = U51

fn pack(self) -> <(U48, U3) as BitPack>::Packed

fn unpack(packed: <(U48, U3) as BitPack>::Packed) -> (U48, U3)

impl BitPack for (U44, U11)

type Packed = U55

fn pack(self) -> <(U44, U11) as BitPack>::Packed

fn unpack(packed: <(U44, U11) as BitPack>::Packed) -> (U44, U11)

impl BitPack for (U11, U13)

type Packed = U24

fn pack(self) -> <(U11, U13) as BitPack>::Packed

fn unpack(packed: <(U11, U13) as BitPack>::Packed) -> (U11, U13)

impl BitPack for (U15, U45)

type Packed = U60

fn pack(self) -> <(U15, U45) as BitPack>::Packed

fn unpack(packed: <(U15, U45) as BitPack>::Packed) -> (U15, U45)

impl BitPack for (U33, U31)

type Packed = u64

fn pack(self) -> <(U33, U31) as BitPack>::Packed

fn unpack(packed: <(U33, U31) as BitPack>::Packed) -> (U33, U31)

impl BitPack for (U1, U6)

type Packed = U7

fn pack(self) -> <(U1, U6) as BitPack>::Packed

fn unpack(packed: <(U1, U6) as BitPack>::Packed) -> (U1, U6)

impl BitPack for (U6, U26)

type Packed = u32

fn pack(self) -> <(U6, U26) as BitPack>::Packed

fn unpack(packed: <(U6, U26) as BitPack>::Packed) -> (U6, U26)

impl BitPack for (U34, U29)

type Packed = U63

fn pack(self) -> <(U34, U29) as BitPack>::Packed

fn unpack(packed: <(U34, U29) as BitPack>::Packed) -> (U34, U29)

impl BitPack for (U28, U27)

type Packed = U55

fn pack(self) -> <(U28, U27) as BitPack>::Packed

fn unpack(packed: <(U28, U27) as BitPack>::Packed) -> (U28, U27)

impl BitPack for (U15, U26)

type Packed = U41

fn pack(self) -> <(U15, U26) as BitPack>::Packed

fn unpack(packed: <(U15, U26) as BitPack>::Packed) -> (U15, U26)

impl BitPack for (U21, U34)

type Packed = U55

fn pack(self) -> <(U21, U34) as BitPack>::Packed

fn unpack(packed: <(U21, U34) as BitPack>::Packed) -> (U21, U34)

impl BitPack for (U33, U28)

type Packed = U61

fn pack(self) -> <(U33, U28) as BitPack>::Packed

fn unpack(packed: <(U33, U28) as BitPack>::Packed) -> (U33, U28)

impl BitPack for (U24, U3)

type Packed = U27

fn pack(self) -> <(U24, U3) as BitPack>::Packed

fn unpack(packed: <(U24, U3) as BitPack>::Packed) -> (U24, U3)

impl BitPack for (U12, U44)

type Packed = U56

fn pack(self) -> <(U12, U44) as BitPack>::Packed

fn unpack(packed: <(U12, U44) as BitPack>::Packed) -> (U12, U44)

impl BitPack for (U1, U7)

type Packed = u8

fn pack(self) -> <(U1, U7) as BitPack>::Packed

fn unpack(packed: <(U1, U7) as BitPack>::Packed) -> (U1, U7)

impl BitPack for (U6, U38)

type Packed = U44

fn pack(self) -> <(U6, U38) as BitPack>::Packed

fn unpack(packed: <(U6, U38) as BitPack>::Packed) -> (U6, U38)

impl BitPack for (U2, U50)

type Packed = U52

fn pack(self) -> <(U2, U50) as BitPack>::Packed

fn unpack(packed: <(U2, U50) as BitPack>::Packed) -> (U2, U50)

impl BitPack for (U3, U25)

type Packed = U28

fn pack(self) -> <(U3, U25) as BitPack>::Packed

fn unpack(packed: <(U3, U25) as BitPack>::Packed) -> (U3, U25)

impl BitPack for (u32, U7)

type Packed = U39

fn pack(self) -> <(u32, U7) as BitPack>::Packed

fn unpack(packed: <(u32, U7) as BitPack>::Packed) -> (u32, U7)

impl BitPack for (U21, U19)

type Packed = U40

fn pack(self) -> <(U21, U19) as BitPack>::Packed

fn unpack(packed: <(U21, U19) as BitPack>::Packed) -> (U21, U19)

impl BitPack for (U10, U19)

type Packed = U29

fn pack(self) -> <(U10, U19) as BitPack>::Packed

fn unpack(packed: <(U10, U19) as BitPack>::Packed) -> (U10, U19)

impl BitPack for (U21, U4)

type Packed = U25

fn pack(self) -> <(U21, U4) as BitPack>::Packed

fn unpack(packed: <(U21, U4) as BitPack>::Packed) -> (U21, U4)

impl BitPack for (U3, U4)

type Packed = U7

fn pack(self) -> <(U3, U4) as BitPack>::Packed

fn unpack(packed: <(U3, U4) as BitPack>::Packed) -> (U3, U4)

impl BitPack for (U3, U43)

type Packed = U46

fn pack(self) -> <(U3, U43) as BitPack>::Packed

fn unpack(packed: <(U3, U43) as BitPack>::Packed) -> (U3, U43)

impl BitPack for (U11, U49)

type Packed = U60

fn pack(self) -> <(U11, U49) as BitPack>::Packed

fn unpack(packed: <(U11, U49) as BitPack>::Packed) -> (U11, U49)

impl BitPack for (U45, U17)

type Packed = U62

fn pack(self) -> <(U45, U17) as BitPack>::Packed

fn unpack(packed: <(U45, U17) as BitPack>::Packed) -> (U45, U17)

impl BitPack for (U2, U60)

type Packed = U62

fn pack(self) -> <(U2, U60) as BitPack>::Packed

fn unpack(packed: <(U2, U60) as BitPack>::Packed) -> (U2, U60)

impl BitPack for (U19, U10)

type Packed = U29

fn pack(self) -> <(U19, U10) as BitPack>::Packed

fn unpack(packed: <(U19, U10) as BitPack>::Packed) -> (U19, U10)

impl BitPack for (U13, U47)

type Packed = U60

fn pack(self) -> <(U13, U47) as BitPack>::Packed

fn unpack(packed: <(U13, U47) as BitPack>::Packed) -> (U13, U47)

impl BitPack for (U10, U2)

type Packed = U12

fn pack(self) -> <(U10, U2) as BitPack>::Packed

fn unpack(packed: <(U10, U2) as BitPack>::Packed) -> (U10, U2)

impl BitPack for (U17, U7)

type Packed = U24

fn pack(self) -> <(U17, U7) as BitPack>::Packed

fn unpack(packed: <(U17, U7) as BitPack>::Packed) -> (U17, U7)

impl BitPack for (U36, U20)

type Packed = U56

fn pack(self) -> <(U36, U20) as BitPack>::Packed

fn unpack(packed: <(U36, U20) as BitPack>::Packed) -> (U36, U20)

impl BitPack for (U20, U41)

type Packed = U61

fn pack(self) -> <(U20, U41) as BitPack>::Packed

fn unpack(packed: <(U20, U41) as BitPack>::Packed) -> (U20, U41)

impl BitPack for (U10, U13)

type Packed = U23

fn pack(self) -> <(U10, U13) as BitPack>::Packed

fn unpack(packed: <(U10, U13) as BitPack>::Packed) -> (U10, U13)

impl BitPack for (U40, U18)

type Packed = U58

fn pack(self) -> <(U40, U18) as BitPack>::Packed

fn unpack(packed: <(U40, U18) as BitPack>::Packed) -> (U40, U18)

impl BitPack for (U4, U39)

type Packed = U43

fn pack(self) -> <(U4, U39) as BitPack>::Packed

fn unpack(packed: <(U4, U39) as BitPack>::Packed) -> (U4, U39)

impl BitPack for (U4, U13)

type Packed = U17

fn pack(self) -> <(U4, U13) as BitPack>::Packed

fn unpack(packed: <(U4, U13) as BitPack>::Packed) -> (U4, U13)

impl BitPack for (U31, U23)

type Packed = U54

fn pack(self) -> <(U31, U23) as BitPack>::Packed

fn unpack(packed: <(U31, U23) as BitPack>::Packed) -> (U31, U23)

impl BitPack for (U17, u16)

type Packed = U33

fn pack(self) -> <(U17, u16) as BitPack>::Packed

fn unpack(packed: <(U17, u16) as BitPack>::Packed) -> (U17, u16)

impl BitPack for (U36, U21)

type Packed = U57

fn pack(self) -> <(U36, U21) as BitPack>::Packed

fn unpack(packed: <(U36, U21) as BitPack>::Packed) -> (U36, U21)

impl BitPack for (U12, U38)

type Packed = U50

fn pack(self) -> <(U12, U38) as BitPack>::Packed

fn unpack(packed: <(U12, U38) as BitPack>::Packed) -> (U12, U38)

impl<T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T14, <(T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T14, <(T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U24, U9)

type Packed = U33

fn pack(self) -> <(U24, U9) as BitPack>::Packed

fn unpack(packed: <(U24, U9) as BitPack>::Packed) -> (U24, U9)

impl BitPack for (U24, U37)

type Packed = U61

fn pack(self) -> <(U24, U37) as BitPack>::Packed

fn unpack(packed: <(U24, U37) as BitPack>::Packed) -> (U24, U37)

impl BitPack for (U27, U24)

type Packed = U51

fn pack(self) -> <(U27, U24) as BitPack>::Packed

fn unpack(packed: <(U27, U24) as BitPack>::Packed) -> (U27, U24)

impl BitPack for (U25, U3)

type Packed = U28

fn pack(self) -> <(U25, U3) as BitPack>::Packed

fn unpack(packed: <(U25, U3) as BitPack>::Packed) -> (U25, U3)

impl BitPack for (u32, U15)

type Packed = U47

fn pack(self) -> <(u32, U15) as BitPack>::Packed

fn unpack(packed: <(u32, U15) as BitPack>::Packed) -> (u32, U15)

impl BitPack for (U45, U5)

type Packed = U50

fn pack(self) -> <(U45, U5) as BitPack>::Packed

fn unpack(packed: <(U45, U5) as BitPack>::Packed) -> (U45, U5)

impl BitPack for (U30, U19)

type Packed = U49

fn pack(self) -> <(U30, U19) as BitPack>::Packed

fn unpack(packed: <(U30, U19) as BitPack>::Packed) -> (U30, U19)

impl BitPack for (U41, U5)

type Packed = U46

fn pack(self) -> <(U41, U5) as BitPack>::Packed

fn unpack(packed: <(U41, U5) as BitPack>::Packed) -> (U41, U5)

impl BitPack for (U46, u8)

type Packed = U54

fn pack(self) -> <(U46, u8) as BitPack>::Packed

fn unpack(packed: <(U46, u8) as BitPack>::Packed) -> (U46, u8)

impl BitPack for (U23, u32)

type Packed = U55

fn pack(self) -> <(U23, u32) as BitPack>::Packed

fn unpack(packed: <(U23, u32) as BitPack>::Packed) -> (U23, u32)

impl BitPack for (U6, U22)

type Packed = U28

fn pack(self) -> <(U6, U22) as BitPack>::Packed

fn unpack(packed: <(U6, U22) as BitPack>::Packed) -> (U6, U22)

impl BitPack for (U2, U46)

type Packed = U48

fn pack(self) -> <(U2, U46) as BitPack>::Packed

fn unpack(packed: <(U2, U46) as BitPack>::Packed) -> (U2, U46)

impl BitPack for (U18, U23)

type Packed = U41

fn pack(self) -> <(U18, U23) as BitPack>::Packed

fn unpack(packed: <(U18, U23) as BitPack>::Packed) -> (U18, U23)

impl<T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T53, <(T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T53, <(T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U43, U11)

type Packed = U54

fn pack(self) -> <(U43, U11) as BitPack>::Packed

fn unpack(packed: <(U43, U11) as BitPack>::Packed) -> (U43, U11)

impl BitPack for (U15, u8)

type Packed = U23

fn pack(self) -> <(U15, u8) as BitPack>::Packed

fn unpack(packed: <(U15, u8) as BitPack>::Packed) -> (U15, u8)

impl BitPack for (U4, U25)

type Packed = U29

fn pack(self) -> <(U4, U25) as BitPack>::Packed

fn unpack(packed: <(U4, U25) as BitPack>::Packed) -> (U4, U25)

impl BitPack for (U20, U25)

type Packed = U45

fn pack(self) -> <(U20, U25) as BitPack>::Packed

fn unpack(packed: <(U20, U25) as BitPack>::Packed) -> (U20, U25)

impl BitPack for (U18, U34)

type Packed = U52

fn pack(self) -> <(U18, U34) as BitPack>::Packed

fn unpack(packed: <(U18, U34) as BitPack>::Packed) -> (U18, U34)

impl BitPack for (U3, U42)

type Packed = U45

fn pack(self) -> <(U3, U42) as BitPack>::Packed

fn unpack(packed: <(U3, U42) as BitPack>::Packed) -> (U3, U42)

impl BitPack for (U30, U30)

type Packed = U60

fn pack(self) -> <(U30, U30) as BitPack>::Packed

fn unpack(packed: <(U30, U30) as BitPack>::Packed) -> (U30, U30)

impl BitPack for (U28, U36)

type Packed = u64

fn pack(self) -> <(U28, U36) as BitPack>::Packed

fn unpack(packed: <(U28, U36) as BitPack>::Packed) -> (U28, U36)

impl BitPack for (U19, u32)

type Packed = U51

fn pack(self) -> <(U19, u32) as BitPack>::Packed

fn unpack(packed: <(U19, u32) as BitPack>::Packed) -> (U19, u32)

impl BitPack for (U17, U24)

type Packed = U41

fn pack(self) -> <(U17, U24) as BitPack>::Packed

fn unpack(packed: <(U17, U24) as BitPack>::Packed) -> (U17, U24)

impl BitPack for (U28, U22)

type Packed = U50

fn pack(self) -> <(U28, U22) as BitPack>::Packed

fn unpack(packed: <(U28, U22) as BitPack>::Packed) -> (U28, U22)

impl BitPack for (U11, U5)

type Packed = u16

fn pack(self) -> <(U11, U5) as BitPack>::Packed

fn unpack(packed: <(U11, U5) as BitPack>::Packed) -> (U11, U5)

impl<T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T44, <(T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T44, <(T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U14, U11)

type Packed = U25

fn pack(self) -> <(U14, U11) as BitPack>::Packed

fn unpack(packed: <(U14, U11) as BitPack>::Packed) -> (U14, U11)

impl BitPack for (U7, U14)

type Packed = U21

fn pack(self) -> <(U7, U14) as BitPack>::Packed

fn unpack(packed: <(U7, U14) as BitPack>::Packed) -> (U7, U14)

impl BitPack for (U7, U25)

type Packed = u32

fn pack(self) -> <(U7, U25) as BitPack>::Packed

fn unpack(packed: <(U7, U25) as BitPack>::Packed) -> (U7, U25)

impl BitPack for (U11, U10)

type Packed = U21

fn pack(self) -> <(U11, U10) as BitPack>::Packed

fn unpack(packed: <(U11, U10) as BitPack>::Packed) -> (U11, U10)

impl BitPack for (u16, U35)

type Packed = U51

fn pack(self) -> <(u16, U35) as BitPack>::Packed

fn unpack(packed: <(u16, U35) as BitPack>::Packed) -> (u16, U35)

impl BitPack for (U13, U9)

type Packed = U22

fn pack(self) -> <(U13, U9) as BitPack>::Packed

fn unpack(packed: <(U13, U9) as BitPack>::Packed) -> (U13, U9)

impl BitPack for (U10, U30)

type Packed = U40

fn pack(self) -> <(U10, U30) as BitPack>::Packed

fn unpack(packed: <(U10, U30) as BitPack>::Packed) -> (U10, U30)

impl BitPack for (U44, U6)

type Packed = U50

fn pack(self) -> <(U44, U6) as BitPack>::Packed

fn unpack(packed: <(U44, U6) as BitPack>::Packed) -> (U44, U6)

impl BitPack for (U2, U49)

type Packed = U51

fn pack(self) -> <(U2, U49) as BitPack>::Packed

fn unpack(packed: <(U2, U49) as BitPack>::Packed) -> (U2, U49)

impl BitPack for (U25, U24)

type Packed = U49

fn pack(self) -> <(U25, U24) as BitPack>::Packed

fn unpack(packed: <(U25, U24) as BitPack>::Packed) -> (U25, U24)

impl BitPack for (U15, U29)

type Packed = U44

fn pack(self) -> <(U15, U29) as BitPack>::Packed

fn unpack(packed: <(U15, U29) as BitPack>::Packed) -> (U15, U29)

impl BitPack for (u8, U26)

type Packed = U34

fn pack(self) -> <(u8, U26) as BitPack>::Packed

fn unpack(packed: <(u8, U26) as BitPack>::Packed) -> (u8, U26)

impl BitPack for (U1, U57)

type Packed = U58

fn pack(self) -> <(U1, U57) as BitPack>::Packed

fn unpack(packed: <(U1, U57) as BitPack>::Packed) -> (U1, U57)

impl BitPack for (U29, U20)

type Packed = U49

fn pack(self) -> <(U29, U20) as BitPack>::Packed

fn unpack(packed: <(U29, U20) as BitPack>::Packed) -> (U29, U20)

impl BitPack for (U18, U14)

type Packed = u32

fn pack(self) -> <(U18, U14) as BitPack>::Packed

fn unpack(packed: <(U18, U14) as BitPack>::Packed) -> (U18, U14)

impl BitPack for (U21, U12)

type Packed = U33

fn pack(self) -> <(U21, U12) as BitPack>::Packed

fn unpack(packed: <(U21, U12) as BitPack>::Packed) -> (U21, U12)

impl BitPack for (U4, U30)

type Packed = U34

fn pack(self) -> <(U4, U30) as BitPack>::Packed

fn unpack(packed: <(U4, U30) as BitPack>::Packed) -> (U4, U30)

impl BitPack for (U30, U13)

type Packed = U43

fn pack(self) -> <(U30, U13) as BitPack>::Packed

fn unpack(packed: <(U30, U13) as BitPack>::Packed) -> (U30, U13)

impl BitPack for (U44, U2)

type Packed = U46

fn pack(self) -> <(U44, U2) as BitPack>::Packed

fn unpack(packed: <(U44, U2) as BitPack>::Packed) -> (U44, U2)

impl BitPack for (U15, U6)

type Packed = U21

fn pack(self) -> <(U15, U6) as BitPack>::Packed

fn unpack(packed: <(U15, U6) as BitPack>::Packed) -> (U15, U6)

impl BitPack for (U14, U44)

type Packed = U58

fn pack(self) -> <(U14, U44) as BitPack>::Packed

fn unpack(packed: <(U14, U44) as BitPack>::Packed) -> (U14, U44)

impl BitPack for (U24, U40)

type Packed = u64

fn pack(self) -> <(U24, U40) as BitPack>::Packed

fn unpack(packed: <(U24, U40) as BitPack>::Packed) -> (U24, U40)

impl BitPack for (U29, U9)

type Packed = U38

fn pack(self) -> <(U29, U9) as BitPack>::Packed

fn unpack(packed: <(U29, U9) as BitPack>::Packed) -> (U29, U9)

impl BitPack for (U14, U41)

type Packed = U55

fn pack(self) -> <(U14, U41) as BitPack>::Packed

fn unpack(packed: <(U14, U41) as BitPack>::Packed) -> (U14, U41)

impl BitPack for (U13, U44)

type Packed = U57

fn pack(self) -> <(U13, U44) as BitPack>::Packed

fn unpack(packed: <(U13, U44) as BitPack>::Packed) -> (U13, U44)

impl BitPack for (U4, U59)

type Packed = U63

fn pack(self) -> <(U4, U59) as BitPack>::Packed

fn unpack(packed: <(U4, U59) as BitPack>::Packed) -> (U4, U59)

impl BitPack for (U50, U13)

type Packed = U63

fn pack(self) -> <(U50, U13) as BitPack>::Packed

fn unpack(packed: <(U50, U13) as BitPack>::Packed) -> (U50, U13)

impl BitPack for (U18, U44)

type Packed = U62

fn pack(self) -> <(U18, U44) as BitPack>::Packed

fn unpack(packed: <(U18, U44) as BitPack>::Packed) -> (U18, U44)

impl BitPack for (U50, U7)

type Packed = U57

fn pack(self) -> <(U50, U7) as BitPack>::Packed

fn unpack(packed: <(U50, U7) as BitPack>::Packed) -> (U50, U7)

impl BitPack for (U15, U3)

type Packed = U18

fn pack(self) -> <(U15, U3) as BitPack>::Packed

fn unpack(packed: <(U15, U3) as BitPack>::Packed) -> (U15, U3)

impl BitPack for (U30, U26)

type Packed = U56

fn pack(self) -> <(U30, U26) as BitPack>::Packed

fn unpack(packed: <(U30, U26) as BitPack>::Packed) -> (U30, U26)

impl BitPack for (U15, U19)

type Packed = U34

fn pack(self) -> <(U15, U19) as BitPack>::Packed

fn unpack(packed: <(U15, U19) as BitPack>::Packed) -> (U15, U19)

impl BitPack for (U21, U3)

type Packed = U24

fn pack(self) -> <(U21, U3) as BitPack>::Packed

fn unpack(packed: <(U21, U3) as BitPack>::Packed) -> (U21, U3)

impl BitPack for (U31, U22)

type Packed = U53

fn pack(self) -> <(U31, U22) as BitPack>::Packed

fn unpack(packed: <(U31, U22) as BitPack>::Packed) -> (U31, U22)

impl BitPack for (U43, U3)

type Packed = U46

fn pack(self) -> <(U43, U3) as BitPack>::Packed

fn unpack(packed: <(U43, U3) as BitPack>::Packed) -> (U43, U3)

impl BitPack for (U26, U9)

type Packed = U35

fn pack(self) -> <(U26, U9) as BitPack>::Packed

fn unpack(packed: <(U26, U9) as BitPack>::Packed) -> (U26, U9)

impl BitPack for (U29, U17)

type Packed = U46

fn pack(self) -> <(U29, U17) as BitPack>::Packed

fn unpack(packed: <(U29, U17) as BitPack>::Packed) -> (U29, U17)

impl BitPack for (U39, U14)

type Packed = U53

fn pack(self) -> <(U39, U14) as BitPack>::Packed

fn unpack(packed: <(U39, U14) as BitPack>::Packed) -> (U39, U14)

impl BitPack for (U12, U31)

type Packed = U43

fn pack(self) -> <(U12, U31) as BitPack>::Packed

fn unpack(packed: <(U12, U31) as BitPack>::Packed) -> (U12, U31)

impl BitPack for (u32, U24)

type Packed = U56

fn pack(self) -> <(u32, U24) as BitPack>::Packed

fn unpack(packed: <(u32, U24) as BitPack>::Packed) -> (u32, U24)

impl<T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> BitPack for (T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)where
    (T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64): BitPack,
    (T7, <(T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed): BitPack,

type Packed = <(T7, <(T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed) as BitPack>::Packed

fn pack(
    self
) -> <(T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed

fn unpack(
    packed: <(T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64) as BitPack>::Packed
) -> (T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64)

impl BitPack for (U17, U3)

type Packed = U20

fn pack(self) -> <(U17, U3) as BitPack>::Packed

fn unpack(packed: <(U17, U3) as BitPack>::Packed) -> (U17, U3)

impl BitPack for (U22, U12)

type Packed = U34

fn pack(self) -> <(U22, U12) as BitPack>::Packed

fn unpack(packed: <(U22, U12) as BitPack>::Packed) -> (U22, U12)

impl BitPack for (U4, U27)

type Packed = U31

fn pack(self) -> <(U4, U27) as BitPack>::Packed

fn unpack(packed: <(U4, U27) as BitPack>::Packed) -> (U4, U27)

impl BitPack for (u8, u8)

type Packed = u16

fn pack(self) -> <(u8, u8) as BitPack>::Packed

fn unpack(packed: <(u8, u8) as BitPack>::Packed) -> (u8, u8)

impl BitPack for (u16, U3)

type Packed = U19

fn pack(self) -> <(u16, U3) as BitPack>::Packed

fn unpack(packed: <(u16, U3) as BitPack>::Packed) -> (u16, U3)

impl BitPack for (U42, u8)

type Packed = U50

fn pack(self) -> <(U42, u8) as BitPack>::Packed

fn unpack(packed: <(U42, u8) as BitPack>::Packed) -> (U42, u8)

impl BitPack for (U7, U54)

type Packed = U61

fn pack(self) -> <(U7, U54) as BitPack>::Packed

fn unpack(packed: <(U7, U54) as BitPack>::Packed) -> (U7, U54)

impl BitPack for (u8, U37)

type Packed = U45

fn pack(self) -> <(u8, U37) as BitPack>::Packed

fn unpack(packed: <(u8, U37) as BitPack>::Packed) -> (u8, U37)

impl BitPack for (U5, U56)

type Packed = U61

fn pack(self) -> <(U5, U56) as BitPack>::Packed

fn unpack(packed: <(U5, U56) as BitPack>::Packed) -> (U5, U56)

impl BitPack for (U42, U11)

type Packed = U53

fn pack(self) -> <(U42, U11) as BitPack>::Packed

fn unpack(packed: <(U42, U11) as BitPack>::Packed) -> (U42, U11)

impl BitPack for (U46, U12)

type Packed = U58

fn pack(self) -> <(U46, U12) as BitPack>::Packed

fn unpack(packed: <(U46, U12) as BitPack>::Packed) -> (U46, U12)

impl BitPack for (U3, U22)

type Packed = U25

fn pack(self) -> <(U3, U22) as BitPack>::Packed

fn unpack(packed: <(U3, U22) as BitPack>::Packed) -> (U3, U22)

impl BitPack for (U5, U22)

type Packed = U27

fn pack(self) -> <(U5, U22) as BitPack>::Packed

fn unpack(packed: <(U5, U22) as BitPack>::Packed) -> (U5, U22)

impl BitPack for (U22, U4)

type Packed = U26

fn pack(self) -> <(U22, U4) as BitPack>::Packed

fn unpack(packed: <(U22, U4) as BitPack>::Packed) -> (U22, U4)

impl BitPack for (U51, U11)

type Packed = U62

fn pack(self) -> <(U51, U11) as BitPack>::Packed

fn unpack(packed: <(U51, U11) as BitPack>::Packed) -> (U51, U11)

impl BitPack for (U11, u32)

type Packed = U43

fn pack(self) -> <(U11, u32) as BitPack>::Packed

fn unpack(packed: <(U11, u32) as BitPack>::Packed) -> (U11, u32)

impl BitPack for (U31, U5)

type Packed = U36

fn pack(self) -> <(U31, U5) as BitPack>::Packed

fn unpack(packed: <(U31, U5) as BitPack>::Packed) -> (U31, U5)

impl BitPack for (U56, U4)

type Packed = U60

fn pack(self) -> <(U56, U4) as BitPack>::Packed

fn unpack(packed: <(U56, U4) as BitPack>::Packed) -> (U56, U4)

impl BitPack for (U5, U36)

type Packed = U41

fn pack(self) -> <(U5, U36) as BitPack>::Packed

fn unpack(packed: <(U5, U36) as BitPack>::Packed) -> (U5, U36)

Implementors